using System;
using System.Collections.Generic;
using System.Threading;
using System.Web.UI.WebControls;
using System.Windows.Forms;
using TBF.Rig.Sequences;
using TBF.Rig.TestMethods.iPerlCommunication.communication;
using TBF.Rig.TestMethods.iPerlCommunication.communication.C4.protocolCommons;

namespace TBF.Rig.TestMethods.iPerlCommunication.iPerlHead
{
    public partial class IperlHeadTestCtrl : UserControl
    {
        IperlHeadCfg config;
        IperlHead iPerlHead;
        Thread optoThread;

        private bool stopWorkerThread;
        public event EventHandler<OptoReceivedEventArgs> OptoReceivedHandler;

        public IperlHeadTestCtrl(IperlHeadCfg config)
        {
            this.config = config;
            InitializeComponent();
            if (config == null) return;

            iPerlCommunicationForm.cfg = new TestMethodCfg(null); // default values for iPerlCommunication

            foreach(var head in ProcessData.IperlHeads)
            {
                if (head != null && head.Name == config.Name) { iPerlHead = head; }
            }

            rfidCommandComboBox.DisplayMember = "Name";
            rfidCommandComboBox.ValueMember = "Value";
            var items = new[]
            {
                new {Name = "Read PCB", Value = "ReadPCB" },
                new {Name = "Read Additional Common Parameters", Value = "ReadAdditionalCommonParameters" },
                new {Name = "Set Test Mode", Value = "SetTestMode" },
                new {Name = "Set Active Mode", Value = "SetActiveMode" },
                new {Name = "Set Flip Mode Constant", Value = "SetFlipModeConstant" },
                new {Name = "Set Flip Mode Randomized", Value = "SetFlipModeRandomized" },
#if DEBUG
                new {Name = "Start Read Opto Data", Value = "ReadOptoData" },
                new {Name = "Stop Read Opto Data", Value = "StopReadOptoData" },
#endif
                new {Name = " ", Value = "" },
                new {Name = "Reset NFC Head", Value = "ResetNfcHead" },
                new {Name = "Set NFC Head Interface", Value = "SetNfcHead" },
                new {Name = "Set RFID Head interface", Value = "SetRfidHead" }
            };
            /*
            // CTRL+ALT+double click - hidden poweruser menu
            if (((Keyboard.ModifierKeys & Keys.Control) == Keys.Control) && ((Keyboard.ModifierKeys & Keys.Alt) == Keys.Alt) && Users.CurrentUser.AuthorizedAs == AuthorizedAs.PowerUser) 
            {
                Array.Resize(ref items, items.Length + 1);
                items[items.Length - 1] = new { Name = "Kluc", Value = "Kluc" };
            }
            */
            rfidCommandComboBox.DataSource = items;

            stopWorkerThread = false;

            OptoReceivedHandler += (EventHandler<OptoReceivedEventArgs>)((sndr, args) =>
            {
                if (this.InvokeRequired)
                    this.Invoke((Delegate)new EventHandler<OptoReceivedEventArgs>(this.OnOptoReceived2), sndr, (object)args);
                else
                    this.OnOptoReceived2(sndr, args);
            });
        }

        public void OnOptoReceived2(object sender, OptoReceivedEventArgs args)
        {
            optoListBox.Items.Insert(0,args.Data);
        }

        private void CommandTestButtonClick(object sender, MouseEventArgs e)
        {
            rfidOutputListBox.Items.Clear();

            using (Tools.LogChecker logChecker = new Tools.LogChecker("RfidData", log4net.Core.Level.Debug))
            {
                ListItem rfidListItem = new ListItem();
                rfidListItem.Attributes.Add("style", "font-volume:bold");
                //rfidListItem.Attributes.Add("style", "font-weight:bold");
                
                List<ListItem> additionalItems = new List<ListItem>();
                
                bool isTestModeSuccessful = false;
                switch (rfidCommandComboBox.SelectedValue)
                {
                    case "ReadPCB":
                        rfidListItem.Text = $"PCB: {iPerlHead.OptoHeadTest.ReadRequest_PCB()}";
                        break;
                    case "ReadAdditionalCommonParameters":
                    {
                        if (iPerlHead == null)
                        {
                            rfidListItem.Text = "FAILED: iPerl head is not available.";
                            break;
                        }

                        if (iPerlHead.OptoHeadTest == null)
                        {
                            rfidListItem.Text = "FAILED: OptoHeadTest is not available.";
                            break;
                        }

                        bool successful = iPerlHead.OptoHeadTest.ReadAdditionalCommonParameters( out string result, true);
                        
                        if (!successful)
                        {
                            rfidListItem.Text = "FAILED: " + result;
                            break;
                        }
                        
                        rfidListItem.Text = "Additional common parameters:";

                        string[] resultLines = result.Split(
                            new[] { "\r\n", "\n", "\r" },
                            StringSplitOptions.RemoveEmptyEntries);

                        foreach (string line in resultLines)
                        {
                            additionalItems.Add( new ListItem("  " + line.Trim()));
                        }
                        
                        break;
                    }
                    case "SetTestMode":
                        rfidListItem.Text = iPerlHead.OptoHeadTest.SetTestMode(ref isTestModeSuccessful);
                        optoListBox.Items.Clear();
                        stopWorkerThread = false;
                        optoThread = new Thread(OptoWorker);
                        if (!optoThread.IsAlive)
                        {
                            iPerlHead.StartDataStreamProcessing(); // open opto port
                            optoThread.Start();
                        }
                        break;
                    case "SetActiveMode":
                        
                        rfidListItem.Text = iPerlHead.OptoHeadTest.SetActiveMode(ref isTestModeSuccessful);
                        stopWorkerThread = true;
                        iPerlHead.StopDataStreamProcessing(); // close opto port
                        break;
                    case "SetFlipModeConstant":
                    {
                        if (iPerlHead == null || iPerlHead.OptoHeadTest == null)
                        {
                            rfidListItem.Text = "Set Flip Mode Constant (0x00) - FAILED: iPerl head is not available.";
                            break;
                        }

                        bool successful = iPerlHead.OptoHeadTest.SetFlipMode(FlipMode.Constant);
                        rfidListItem.Text = successful
                            ? "Set Flip Mode Constant (0x00) - OK"
                            : "Set Flip Mode Constant (0x00) - FAILED";
                        break;
                    }
                    case "SetFlipModeRandomized":
                    {
                        if (iPerlHead == null || iPerlHead.OptoHeadTest == null)
                        {
                            rfidListItem.Text = "Set Flip Mode Randomized (0x01) - FAILED: iPerl head is not available.";
                            break;
                        }

                        bool successful = iPerlHead.OptoHeadTest.SetFlipMode(FlipMode.Randomized);
                        rfidListItem.Text = successful
                            ? "Set Flip Mode Randomized (0x01) - OK"
                            : "Set Flip Mode Randomized (0x01) - FAILED";
                        break;
                    }
                    case "ResetNfcHead":
                        iPerlHead.ResetNfcInterface();
                        break;
                    case "SetNfcHead":
                        iPerlHead.SetNfcInterface();
                        break;
                    case "SetRfidHead":
                        iPerlHead.SetRfidInterface();
                        break;
                    case "ReadOptoData":
                        optoListBox.Items.Clear();
                        stopWorkerThread = false;
                        optoThread = new Thread(OptoWorker);
                        if (optoThread.IsAlive)
                        {
                            stopWorkerThread = true;
                            iPerlHead.StopDataStreamProcessing(); // close opto port
                        }
                        if (!optoThread.IsAlive)
                        {
                            iPerlHead.StartDataStreamProcessing(); // open opto port
                            optoThread.Start();
                        }
                        break;
                    case "StopReadOptoData":
                        stopWorkerThread = true;
                        iPerlHead.StopDataStreamProcessing(); // close opto port
                        break;
                }
                rfidOutputListBox.Items.Add(rfidListItem);
                foreach (ListItem item in additionalItems)
                {
                    rfidOutputListBox.Items.Add(item);
                }

                rfidOutputListBox.Items.AddRange(logChecker.Messages.ToArray());
            }
        }

        private void OptoWorker()
        {
            while (!this.stopWorkerThread)
            {
                Thread.Sleep(250);
                if (this.stopWorkerThread)
                    break;

                try
                {
                    string buffer = iPerlHead.ReadOptoData();
                    if (string.IsNullOrEmpty(buffer))
                    {
                        this.OnOptoReceived((object)this, new OptoReceivedEventArgs("."));
                    }
                    else
                        OnOptoReceived((object)this, new OptoReceivedEventArgs(buffer));
                }
                catch (Exception ex)
                {
                    this.OnOptoReceived((object)this, new OptoReceivedEventArgs(ex.Message));
                }
            }
        }

        public void OnOptoReceived(object sender, OptoReceivedEventArgs args)
        {
            if (this.OptoReceivedHandler == null)
                return;
            try
            {
                this.OptoReceivedHandler(sender, args);
            }
            catch (Exception ex)
            {
            }
        }

        private void UserControl_Load(object sender, EventArgs e)
        {
            this.ParentForm.FormClosing += new FormClosingEventHandler(ParentForm_FormClosing);
        }

        void ParentForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            //OnHandleDestroyed(new EventArgs());
            stopWorkerThread = true;
            if (optoThread != null)
            {
                optoThread.Abort();
            }
        }
    }
}