using CordonelPreadjustmentUi;
using Logic.ProductionToProductMapper.Cordonel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Logic.ProductionOrderCore.OrderData;
using Xylem.Common.Logic.SoftwareAccessHelper;
using XylemCommonUiLegacyGenCtl.DataPackage;
using XylemCommonUiLegacyGenCtl.Enums;
using static Xylem.Common.Ui.CordonelPreadjustmentUi.MeterStateControl;

namespace XylemCommonUiLegacyGenCtl
{
    [Guid("4F5EA77A-AAAA-4909-9419-B8ED1B63BA28"),
    ComVisible(true),
    ClassInterface(ClassInterfaceType.None),
    ComSourceInterfaces(typeof(ITestBenchEvents))]

    public partial class ctlBenchRdy : UserControl, ICtlTestBench, IDisposable
    {
        private Dictionary<int, ctlMeterReady> MeterControls;
        private MeterBatch meterBatch;

        public delegate void OnUserInputDoneDelegate();
        private event OnUserInputDoneDelegate OnUserInputDone;

        private int testBenchId { get; set; }
        private int userId { get; set; }

        private DefaultSettings SettingsToUse;

        public ctlBenchRdy()
        {
            InitializeComponent();

        }

        private void ctlMeterReady1_Load(object sender, EventArgs e)
        {

        }

        public void Init(int v, int TestBenchId, int UserId, bool Research)
        {
            testBenchId = TestBenchId;
            userId = UserId;
            meterBatch = new MeterBatch();
            MeterControls = new Dictionary<int, ctlMeterReady>();
            MeterControls.Add(1, ctlMeterReady1);
            MeterControls.Add(2, ctlMeterReady2);
            MeterControls.Add(3, ctlMeterReady3);
            MeterControls.Add(4, ctlMeterReady4);
            MeterControls.Add(5, ctlMeterReady5);
            MeterControls.Add(6, ctlMeterReady6);
            MeterControls.Add(7, ctlMeterReady7);
            MeterControls.Add(8, ctlMeterReady8);
            MeterControls.Add(9, ctlMeterReady9);
            MeterControls.Add(10, ctlMeterReady10);
            foreach (var item in MeterControls)
            {
                item.Value.SetSlot(item.Key, meterBatch);

                item.Value.Enabled = false;
                item.Value.Visible = false;
            }
            for (int i = 1; i <= v; i++)
            {
                MeterControls[i].Enabled = true;
                MeterControls[i].Visible = true;
                MeterControls[i].OnStateChanged += ctlCheckTestBenchReady_Load;
            }

            var settings = new DefaultSettings();
            if (TestBenchId == 2016)
            {
                settings.Adjustment = DefaultSettings.DetectedMeterEnum.Always;
                settings.FlowAdjustmentTarget = 0.35M;
                settings.FlowTesting = DefaultSettings.DetectedMeterEnum.Always;
                settings.PreAdjustment = DefaultSettings.DetectedMeterEnum.Always;
                settings.Temp = TempSouceType.TempFlansh;
                settings.Delay = 10;
                settings.Research = false;

            }
            Usedefault(settings);


        }


        private void button1_Click(object sender, EventArgs e)
        {

        }

        private void ctlCheckTestBenchReady_Load(object sender, EventArgs e)
        {

        }

        public new void Dispose()
        {
            base.Dispose();

        }

        private void lblDoPreajdus_Click(object sender, EventArgs e)
        {
            cbxDoPreajdustment.Checked = !cbxDoPreajdustment.Checked;
        }

        private void duFlowCalibration_Click(object sender, EventArgs e)
        {
            cbDoFlowCalibration.Checked = !cbDoFlowCalibration.Checked;
        }

        private void cbDoFlowCalibration_CheckedChanged(object sender, EventArgs e)
        {
            if (cbDoFlowCalibration.Checked)
            {
                cbDoFlowCalibration.Text = "V";
            }
            else
            {
                cbDoFlowCalibration.Text = "-";
            }
            foreach (var item in MeterControls)
            {
                if (item.Value.Enabled && item.Value.PcbId != "-" && item.Value.PcbId != "")
                {
                    item.Value.SetFlowCalibration(cbDoFlowCalibration.Checked);
                }

            }
        }

        private void cbxDoPreajdustment_CheckedChanged(object sender, EventArgs e)
        {
            if (cbxDoPreajdustment.Checked)
            {
                cbxDoPreajdustment.Text = "V";
            }
            else
            {
                cbxDoPreajdustment.Text = "-";
            }
            foreach (var item in MeterControls)
            {
                if (item.Value.Enabled && item.Value.PcbId != "-" && item.Value.PcbId != "")
                {
                    item.Value.SetPreadjustmentValue(cbxDoPreajdustment.Checked);
                }

            }

        }

        private void nudCalibrationTarget_ValueChanged(object sender, EventArgs e)
        {
            foreach (var item in MeterControls)
            {
                if (item.Value.Enabled && item.Value.PcbId != "-" && item.Value.PcbId != "")
                {
                    item.Value.SetCalibrationTarget(nudCalibrationTarget.Value);
                }

            }
        }

        private void btnTemp11_Click(object sender, EventArgs e)
        {
            CheckTempFlansh(btnTemp11, lblTempTF11, 11);
        }

        private void CheckTempFlansh(Button btnTemp, Label lblTempTF, int Slot)
        {
            if (btnTemp.Text == "A")
            {
                var tempText = "...";
                lblTempTF.Text = tempText;
                btnTemp.Text = "W";
                var t = new Task(() =>
                {

                    try
                    {
                        var temp = GetTempCalcToF(Slot);
                        if (temp.HasValue)
                        {
                            tempText = $"{ temp.Value.ToString("N3") } °C";
                        }
                        else
                        {
                            tempText = "NA!";
                        }
                    }
                    catch (Exception)
                    {
                        tempText = "Error!";
                    }

                });
                t.Start();

                t.ContinueWith((r) =>
                {

                    Invoke(new Action(() =>
                    {
                        lblTempTF.Text = tempText;
                        btnTemp.Text = "A";
                    }));
                });
            }
        }


        private void btnTemp12_Click(object sender, EventArgs e)
        {
            CheckTempFlansh(btnTemp12, lblTempTF12, 12);

        }


        private decimal? GetTempCalcToF(int slot)
        {
            try
            {
                using (var ThermoMeterBatch = new MeterBatch())
                {
                    using (var currentMeter = new ZeroFlowGenesisMeter(slot, 3, false))
                    {
                        currentMeter.LogOnEnable = true;
                        currentMeter.LoginFailed = false;
                        currentMeter.PreparationFailed = false;
                        currentMeter.AmplitudeFailed = false;
                        currentMeter.ZeroFlowOffsetFailed = false;
                        currentMeter.AmplitudeFailed = false;
                        currentMeter.CompletionFailed = false;
                        currentMeter.Ok = false;
                        currentMeter.EmptyPipeCheckEnable = false;
                        currentMeter.EmptyPipeCheckFailed = false;

                        ThermoMeterBatch.AddMeter(currentMeter);



                        currentMeter.CheckStreamingPort();


                        currentMeter.StartRecordData();
                        currentMeter.LogRawData(true);



                        List<Tuple<double, double>> TempFromTofLUT;

                        currentMeter.WriteLog($"StartTempWatch on ctlCheckTestBenchReady");

                        currentMeter.logAmpTest = true;

                        TempFromTofLUT = new List<Tuple<double, double>>();

                        var pcbid = "notFound";
                        try
                        {
                            pcbid = currentMeter.GetPcbId();
                            if (string.IsNullOrEmpty(pcbid))
                            {
                                pcbid = currentMeter.GetPcbId();
                            }



                            var resp = LocalWebRequest.GetRequest($"http://10.49.40.25/MeterProcessState/api/TempFlange/GetLut?PcbId={pcbid}", 10000);
                            var cordonelTempLut = JsonConvert.DeserializeObject<List<CordonelTempLut>>(resp);
                            TempFromTofLUT = new List<Tuple<double, double>>();

                            foreach (var item in cordonelTempLut.OrderBy(a => a.RefTempC))
                            {
                                TempFromTofLUT.Add(new Tuple<double, double>(item.AvgTof, item.RefTempC));
                            }

                        }
                        catch (Exception ex)
                        {
                            currentMeter.WriteLog($"StartTempWatch with LUT  faild for meter {pcbid} with ex{ex.Message}");

                        }
                        var till = DateTime.Now.AddSeconds(30);
                        while (currentMeter.CurrentRecords.Count < 250 && DateTime.Now < till)
                        {
                            Thread.Sleep(50);
                        }


                        var cRecords = currentMeter.CurrentRecords.ToList();
                        currentMeter.WriteLog($"cRecords.Count={cRecords.Count}");
                        if (cRecords != null && cRecords.Any())
                        {
                            decimal checkTempMeter = 0;

                            //

                            var sumTof = 0.0;
                            var countTof = 0;
                            foreach (var tofItem in cRecords.Where(c => c.Channel == 2))
                            {


                                if (tofItem.Channel == 2)
                                {
                                    Log($"TotalTimeOfFlightS;{(tofItem.TotalTimeOfFlightS * 1000).ToString()}");
                                    Log($"RAWTEMP;{interPol(TempFromTofLUT, (tofItem.TotalTimeOfFlightS * 1000))}");
                                    sumTof = (tofItem.TotalTimeOfFlightS * 1000) + sumTof;
                                    countTof = countTof + 1;
                                }

                            }

                            var x = (sumTof / countTof) / 1000;


                            Log($"avgTof;{x}({sumTof}/{countTof})");
                            return interPol(TempFromTofLUT, x);

                        }
                        else
                        {
                            Log($"temp  NA");

                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log($"temp  NA - {ex.Message}");
            }
            return null;
        }

        private void Log(string v)
        {

        }





        private static decimal interPol(List<Tuple<double, double>> points, double x)
        {
            var x1 = 0.000;
            var y1 = 0.000;
            var x2 = 0.000;
            var y2 = 0.000;
            decimal checkTempMeter;
            if ((x <= points[0].Item1) && (x >= points.Last().Item1))
            {
                var i = 0;
                foreach (var val in points)
                {
                    if (points[i].Item1 <= x)
                    {
                        x1 = points[i - 1].Item1;
                        y1 = points[i - 1].Item2;
                        x2 = points[i].Item1;
                        y2 = points[i].Item2;
                        break;
                    }
                    i = i + 1;
                }

                checkTempMeter = (decimal)((y2 - y1) / (x2 - x1) * (x - x1) + y1);
            }
            else
            {
                checkTempMeter = 1;
            }

            return checkTempMeter;
        }

        private CancellationTokenSource OverallCancellationTokenSource = new CancellationTokenSource();
        private void button4_Click(object sender, EventArgs e)
        {



            foreach (var item in MeterControls)
            {
                if (item.Value.Enabled)
                {
                    item.Value.Start(OverallCancellationTokenSource.Token, false, SettingsToUse);
                }

            }
        }
        public TestSetupContainer testControler = new TestSetupContainer();
        private void btnTake_Click(object sender, EventArgs e)
        {

            Take(false);

        }

        private void Take(bool start = false)
        {
            OverallCancellationTokenSource.Cancel();
            testControler = new TestSetupContainer();
            if (rbtTempManualInput.Checked)
            {
                testControler.TempSouce = Enums.TempSouceType.ManualInput;
            }
            else if (rbtTempPtOverSps.Checked)
            {
                testControler.TempSouce = Enums.TempSouceType.PtOverSps;
            }
            else if (rbtTempFlansh.Checked)
            {
                testControler.TempSouce = Enums.TempSouceType.TempFlansh;
            }
            else
            {
                //ahhhhhhhhhhhhhhhhh
                testControler.TempSouce = Enums.TempSouceType.ManualInput;
            }
            testControler.ProductionMode = !cbxResearch.Checked;


            testControler.AllChanelsRequired = cbxAllChannlesReq.Checked;

            testControler.DelayInSBeforStart = (int)nudDelay.Value;

            //testControler.MeterSize
            MeterSize biggestMeterSize = MeterSize.DN40;
            testControler.meterTestSettings = new MeterTestSettings[MeterControls.Count];
            foreach (var item in MeterControls)
            {
                if (item.Value.Enabled)
                {
                    if (item.Value.Metersize != MeterSize.NA && biggestMeterSize < item.Value.Metersize)
                    {
                        biggestMeterSize = item.Value.Metersize;
                    }
                    testControler.meterTestSettings[item.Key - 1] = item.Value.GetMeterTestSettings();
                }
            }
            testControler.MeterSize = biggestMeterSize;
            OnUserInputDone?.Invoke();
            testControler.WatingForDecision = false;
        }

        private void button2_Click(object sender, EventArgs e)
        {
            testControler = new TestSetupContainer();
            testControler.WatingForDecision = false;
            OverallCancellationTokenSource.Cancel();
        }

        private void btnRun_Click(object sender, EventArgs e)
        {
            Take(true);
        }

        public dynamic GetContainer()
        {
            return testControler;
        }

        public void Kill()
        {
            Dispose();
        }

        public bool GetWatingForDecision()
        {
            return testControler.WatingForDecision;
        }

        public bool GetDirectStart()
        {
            return testControler.WatingForDecision;
        }

        public TempSouceType GetTempSouce()
        {
            return testControler.TempSouce;
        }

        public int GetMeterSize()
        {
            return (int)testControler.MeterSize;
        }
        public int GetDelayInSBeforStart()
        {
            return testControler.DelayInSBeforStart;
        }

        public bool GetAllChanelsRequired()
        {
            return testControler.AllChanelsRequired;
        }

        public bool GetProductionMode()
        {
            return testControler.ProductionMode;
        }

        public bool GetSlotPresent(int slot)
        {
            var a = testControler.meterTestSettings?.First(w => w.Slot == slot);

            return a != null && !string.IsNullOrEmpty(a.SerialNr) && a.SerialNr != "-" && (a.FlowTesting || a.PreAdjustment || a.FlowAdjustment);
        }

        public string GetSlotSerialNr(int slot)
        {
            return testControler.meterTestSettings?.First(w => w.Slot == slot)?.SerialNr;
        }

        public bool GetSlotFlowAdjustment(int slot)
        {
            var a = testControler.meterTestSettings?.First(w => w.Slot == slot)?.FlowAdjustment;
            return (a ?? false);
        }

        public decimal GetFlowAdjustmentTarget(int slot)
        {
            return (testControler.meterTestSettings?.First(w => w.Slot == slot)?.FlowAdjustmentTarget ?? 0);
        }

        public bool GetPreAdjustment(int slot)
        {
            var a = testControler.meterTestSettings?.First(w => w.Slot == slot)?.PreAdjustment;
            return (a ?? false);
        }


        public bool GetFlowTesting(int slot)
        {
            var a = testControler.meterTestSettings?.First(w => w.Slot == slot)?.FlowTesting;
            return (a ?? false);
        }

        public bool GetSlotFlowAdjustmentAny()
        {
            var a = testControler.meterTestSettings?.Any(w => w != null && w.FlowAdjustment);
            return (a ?? false);
        }

        public bool GetPreAdjustmentAny()
        {
            var a = testControler.meterTestSettings?.Any(w => w != null && w.PreAdjustment);
            return (a ?? false);
        }

        public bool GetSlotFlowTestingAny()
        {
            var a = testControler.meterTestSettings?.Any(w => w != null && w.FlowTesting);
            return (a ?? false);
        }
        private void btnStationDefault_Click(object sender, EventArgs e)
        {
            Usedefault(new DefaultSettings());
        }

        private void Usedefault(DefaultSettings setting)
        {
            cbxAllChannlesReq.Checked = setting.AllChnlsReq;
            nudDelay.Value = setting.Delay;
            nudCalibrationTarget.Value = setting.FlowAdjustmentTarget;

            cbxResearch.Checked = setting.Research;
            switch (setting.Temp)
            {
                case TempSouceType.ManualInput:
                    rbtTempManualInput.Checked = true;
                    break;
                case TempSouceType.PtOverSps:
                    rbtTempPtOverSps.Checked = true;
                    break;
                case TempSouceType.TempFlansh:
                    break;
                default:
                    rbtTempManualInput.Checked = true;
                    break;
            }

            switch (setting.mode)
            {
                case DefaultSettings.ViewMode.Easy:
                    trackBar1.Value = 0;
                    break;
                case DefaultSettings.ViewMode.Mid:
                    trackBar1.Value = 1;
                    break;
                case DefaultSettings.ViewMode.Expert:
                    trackBar1.Value = 2;
                    break;
                default:
                    trackBar1.Value = 2;
                    break;
            }


            SettingsToUse = setting;


        }

        private void ctlMeterReady2_Load(object sender, EventArgs e)
        {

        }

        private void ctlMeterReady2_Click(object sender, EventArgs e)
        {

        }

        private void trackBar1_Scroll(object sender, EventArgs e)
        {

        }

        private void btnUserDefault_Click(object sender, EventArgs e)
        {

        }
    }
}