using CordonelPreadjustmentUi.Processes.Itinerary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
using Xylem.Common.Ui.CordonelPreadjustmentUi.Helper.Extensions;

using static CordonelPreadjustmentUi.PreAdjustmentControl;

namespace CordonelPreadjustmentUi.Processes.Actions
{
    public class TemperatureCalibrationProcess : BaseProcess
    {
        public TemperatureCalibrationProcess(string processName, StatusPanelItems panelState, string performMessage, string failedMessage, int? expectedTimeS) : base(processName, panelState, performMessage, failedMessage, expectedTimeS)
        {
        }

        public override List<Task> StartWork()
        {
            return doWorkProcess(base.CurrentProcessProgress);
        }

        private List<Task> doWorkProcess(ProcessProgress pp)
        {
            #region Wait for settling time (60s)
            for (Int32 Time = pp.Setting.OffsetTestSettlingTime; Time >= 0; Time--)
            {

                pp.StatusLabel = $"{PredefinedMessages.ZeroflowOffsetWaitForSettling(pp.Setting.Culture)}{Time.ToString(pp.Setting.Culture)}";
                Thread.Sleep(1000);
            }
            #endregion

            var MetersToProcess = MeterStateCtls.Where(e => e.IsEnabled).ToList();

            var listOfProcessTask = new List<Task>();


            pp.StatusLabel = (PredefinedMessages.WaitUntilTemperatureAcquisitionFinished(pp.Setting.Culture));
            bool skipMan = false;
            if (pp.Setting.GetTempUseTempFlansh() || TempMeterStateCtls.Any(a => a.IsEnabled))
            {
                skipMan = true;
                //aoutmatic
                decimal avgTemp = 0;
                int TempFlanshCount = 0;
                var listOFEnabledTempMeters = TempMeterStateCtls.Where(a => a.IsEnabled).ToList();
                foreach (var avgTempCtls in listOFEnabledTempMeters)
                {
                    var check = avgTempCtls.GetTemperature();
                    if (check > 2  || ((double)check) != 25.0d )
                    {
                        avgTemp = avgTemp + avgTempCtls.GetTemperature();
                        TempFlanshCount = TempFlanshCount + 1;
                    }
                  
                }
                if (TempFlanshCount == 0)
                {
                    skipMan = false;
                }
                else
                {
                    avgTemp = avgTemp / TempFlanshCount;

                    foreach (var meterctl in MetersToProcess)
                    {
                        meterctl.SetTemperature(avgTemp);
                    }
                }   

            }

            if (!skipMan)
            {
                //manual input
                foreach (var meterctl in MetersToProcess)
                {
                    meterctl.SetTemperature((decimal)25.0);
                }
                pp.RequestTemperatur();
                foreach (var meterctl in TempMeterStateCtls)
                {
                    meterctl.SetTemperature((decimal)25.0);
                    meterctl.OnTempretureChangedHandler += delegate (Object sender, EventArgsDecimal d)
                    {
                        decimal avgTemp = 0;
                        foreach (var tempMeter in TempMeterStateCtls)
                        {
                            avgTemp = avgTemp + tempMeter.GetTemperature();
                        }

                        avgTemp = avgTemp / TempMeterStateCtls.Count;

                        foreach (var updateMeter in MetersToProcess)
                        {
                            updateMeter.SetTemperature(avgTemp);
                        }

                    };


                }
            }



            pp.DebugMessage($"Performing {ProcessName} procedure");

            listOfProcessTask.Add(new Task<bool>(() =>
            {

                pp.RequestTempretureSelection();
                while (!pp.TempretureSelected)
                {

                    Thread.Sleep(100);
                }
                if (pp.Setting.GetTempUsePtOverSps() && pp.PushedTestBenchTemp.HasValue)
                {
                    foreach (var updateMeter in MetersToProcess)
                    {
                        updateMeter.SetTemperature(Convert.ToDecimal(pp.PushedTestBenchTemp.Value));
                    }
                }
                var listOfSubTasks = new List<Task<bool>>();
                foreach (var disableTempInputMeter in MetersToProcess)
                {
                    disableTempInputMeter.DisableTemperatureinput(true);
                }
                foreach (var disableTempInputMeter in TempMeterStateCtls)
                {
                    disableTempInputMeter.DisableTemperatureinput(true);
                }


                foreach (var putTempIntoMeter in MetersToProcess)
                {
                    listOfSubTasks.Add(new Task<bool>(() =>
                    {

                        var originTemp = putTempIntoMeter.GetTemperature();
                        UInt32 TempToRegister = (UInt32)(originTemp * 4096);

                        #region Set temperature calibration register
                        var Ok = false;
                        pp.StatusLabel = PredefinedMessages.WaitUntilRegisterWriteFinished(pp.Setting.Culture);
                        Ok = WriteRegisterSafe(putTempIntoMeter.Meter, "Temperature calibration", Register.Genesisflow.ToFTempCalibrate, TempToRegister, false);
                        if (CheckAbort(Ok, putTempIntoMeter)) { return Ok; }
                        putTempIntoMeter.Meter.calibrationResult.AddAditonlaLog($"Temperature calibration Register", TempToRegister.ToString());
                        putTempIntoMeter.Meter.calibrationResult.AddAditonlaLog($"Temperature calibration Origin", originTemp.ToString());

                        #endregion
                        #region Wait for some seconds
                        const UInt16 WaitingTime = 10;


                        putTempIntoMeter.Meter.listOfTotalTimeOfFlightSPerPath.Update(null, new List<Double>());
                        putTempIntoMeter.Meter.CurrentRecords.Clear();
                        putTempIntoMeter.Meter.logAmpTest = true;


                        for (Int32 Seconds = 0; Seconds < WaitingTime; Seconds++) // eight seconds remove /2
                        {
                            Ok = ActivityCheck(pp, putTempIntoMeter.Meter.listOfTotalTimeOfFlightSPerPath, Seconds);
                            if (CheckAbort(Ok, putTempIntoMeter))
                            {

                                pp.DebugMessage($"Activity check failed", putTempIntoMeter.Meter.Slot, "DC", putTempIntoMeter.Meter.PcbId);
                                return Ok;
                            }
                            pp.StatusLabel = $"{PredefinedMessages.WaitSeconds(Seconds, pp.Setting.Culture)}";
                            Thread.Sleep(1000);
                        }
                        #endregion
                        #region Check temperature
                        putTempIntoMeter.Meter.CurrentRecords.Clear();
                        putTempIntoMeter.Meter.logAmpTest = true;
                        Thread.Sleep(1000);
                        var tmpTempCheckRecords = putTempIntoMeter.Meter.CurrentRecords.ToList();
                        if (tmpTempCheckRecords.Any())
                        {


                            var checkTempMeter = (decimal)tmpTempCheckRecords.Average(a => a.TemperatureDegC);

                            var sbTemp = new StringBuilder();

                            sbTemp.AppendLine(
                                $"Ref. temp = {Math.Round(originTemp, 2).ToString("00.00", pp.Setting.Culture)}°C vs. Meter temp = {checkTempMeter}°C   at {putTempIntoMeter.Meter.Slot}");

                            if (Math.Abs(originTemp - checkTempMeter) > (decimal)pp.Setting.TempDeviationLimit)
                            {
                                pp.DebugMessage($"Temperature check failed", putTempIntoMeter.Meter.Slot, "APP", putTempIntoMeter.Meter.PcbId);
                                Ok = false;
                            }
                            if (CheckAbort(Ok, putTempIntoMeter)) { return Ok; }

                            pp.DebugMessage($"Temperature check OK", putTempIntoMeter.Meter.Slot, "APP", putTempIntoMeter.Meter.PcbId);

                            #endregion


                            #region Get 'TOF offset' registers
                            if (pp.Setting.NumberOfPaths > 0)
                            {
                                byte[] rawResult;
                                Ok = ReadRegister(putTempIntoMeter.Meter, "TOF offset1", Register.Genesisflow.ToFTempOffset1, out rawResult);
                                if (CheckAbort(Ok, putTempIntoMeter)) { return Ok; }
                                if (rawResult != null)
                                {
                                    var tmp = BitConverter.ToInt32(rawResult, 0);
                                }

                            }
                            if (pp.Setting.NumberOfPaths > 1)
                            {
                                byte[] rawResult;
                                Ok = ReadRegister(putTempIntoMeter.Meter, "TOF offset2", Register.Genesisflow.ToFTempOffset2, out rawResult);
                                if (CheckAbort(Ok, putTempIntoMeter)) { return Ok; }
                                if (rawResult != null)
                                {
                                    var tmp = BitConverter.ToInt32(rawResult, 0);
                                }

                            }

                            if (pp.Setting.NumberOfPaths > 2)
                            {
                                byte[] rawResult;
                                Ok = ReadRegister(putTempIntoMeter.Meter, "TOF offset3", Register.Genesisflow.ToFTempOffset3, out rawResult);
                                if (CheckAbort(Ok, putTempIntoMeter)) { return Ok; }
                                if (rawResult != null)
                                {
                                    var tmp = BitConverter.ToInt32(rawResult, 0);
                                }
                            }
                            #endregion



                            putTempIntoMeter.SetWatcher((decimal)pp.Setting.LowerTempLimit, (decimal)pp.Setting.UpperTempLimit, (decimal)pp.Setting.TempDeviationLimit);
                            putTempIntoMeter.StartTempWatch();

                            return true;
                        }
                        else
                        {
                            pp.DebugMessage($"Temperature check failed - No Records", putTempIntoMeter.Meter.Slot, "APP", putTempIntoMeter.Meter.PcbId);
                            return false;
                        }

                    }));
                }

                listOfSubTasks.ForEach(t => t.Start());
                while (!listOfSubTasks.All(t => t.IsCompleted))
                {
                    Thread.Sleep(5);
                }

                return true;

            }));




            return listOfProcessTask;

        }

    }



}