using CordonelPreadjustmentUi;
using CordonelPreadjustmentUi.Processes.Itinerary;
using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Xylem.Common.CommonCore.Consts;
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
using Xylem.Common.Hardware.WaterMeter.MagFlux.MagFluxCore;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Ui.CordonelPreadjustmentUi.Parameters;
using Xylem.Common.Utils.Logging;
using XylemCommonUiLegacyGenCtl.DataPackage;

namespace XylemCommonUiLegacyGenCtl
{
    [Guid("C5367517-AAAA-439A-A124-40A0A95F2A4D"),
    ComVisible(true),
    ClassInterface(ClassInterfaceType.None),
    ComSourceInterfaces(typeof(ICtlPreadjustment))]
    public partial class PreAdjWr : UserControl, ICtlPreadjustment, IDisposable
    {
        private PollingAction pollingAction = PollingAction.IsBusy;
        private PreAdjustmentControl wrappedControl;
        private FlushParams flushParams = null;
        private ILogger _logger = null;
        private List<int> MetersFinallyPassed = new List<int>();
        private TestSetupContainer TestsetuptContainer;

        public MeterTypes Mode { get; private set; }

        public PreAdjWr()
        {
            try
            {
                InitializeComponent();


                _logger = NLogHelper.CreateOrGetLogger("PreAdjWr");

                _logger.Trace("ctor start");
                wrappedControl = new PreAdjustmentControl();
                wrappedControl.OnAbort += WrappedControl_OnAbort;
                wrappedControl.OnIsDone += WrappedControl_OnIsDone;
                wrappedControl.OnRequestFlush += WrappedControl_OnFlushRequested;
                wrappedControl.OnRequestTemperatur += WrappedControl_OnTemperaturRequested;

                if (!this.Controls.Contains(wrappedControl))
                {
                    this.Controls.Add(wrappedControl);
                }
                _logger.Trace("ctor end");
            }
            catch (Exception ex)
            {
                if (_logger != null)
                {
                    _logger.Fatal(ex);
                }
                else
                {
                    MessageBox.Show($"FATAL Ctor {ex.Message}");
                }


            }

        }

        private void ctlAdjustmentWrapper_Load(object sender, EventArgs e)
        {

        }

        public int GetFlushDurationS()
        {
            if (pollingAction != PollingAction.DoFlush)
            {
                return 0;
            }
            return flushParams == null ? 0 : flushParams.DurationS;
        }

        public int GetFlushFlowrateQmH()
        {
            if (pollingAction != PollingAction.DoFlush)
            {
                return 0;
            }
            return flushParams == null ? 0 : flushParams.FlowrateQmH;
        }

        private void WrappedControl_OnFlushRequested(object sender, EventArgsFlushRequest e)
        {
            flushParams = e.Value;
            pollingAction = PollingAction.DoFlush;

        }
        private void WrappedControl_OnTemperaturRequested(object sender, EventArgs e)
        {
            pollingAction = PollingAction.RequestTemp;
        }

        private void WrappedControl_OnIsDone(object sender, EventArgsMeterSuccsessfull e)
        {
            MetersFinallyPassed = e.Value;
            pollingAction = PollingAction.IsDone;
            Dispose(true);
        }
        private void WrappedControl_OnAbort(object sender, EventArgsMeterSuccsessfull e)
        {
            MetersFinallyPassed = e.Value;
            pollingAction = PollingAction.IsOnError;
            Dispose(true);
        }
        // Double upperTempLimit = 35, Double lowerTempLimit = 15, Double tempDeviationLimit = 1, Int32 ampTestTofRecordingTime = 2, Double ampTestTriggerValue = 0.5, bool ampTestGenerateLogfiles = true, bool ampTestGenerateMeanValuesFile = true, Int32 ampTestFirstHitLevelPropMin = 12, Int32 ampTestFirstHitLevelPropMax = 32, Int32 ampTestAmpTestDistance = 7, Int32 ampTestPercentageStart = 5, Int32 ampTestPercentageStop = 40, Int32 ampTestActivityCheckInverval = 2, bool offsetTestGenerateLogfiles = true, Int32 offsetTestUpperVoltageLimitMV = 650, Int32 offsetTestLowerVoltageLimitMV = 200, Int32 offsetTestOffsetLimitPS = 300, Int32 offsetTestSettlingTime = 60, Int32 offsetTestZeroflowOffsetTestNumberOfLines = 9000, Int32 offsetTestActivityCheckInverval = 2, Int32 offsetTestBadDataLimit = 3)


        private bool loadTempMetersConfig(out List<Int32> Meters, out List<Int32> TempMeters)
        {
            TempMeters = new List<Int32>();
            Meters = new List<Int32>();

            var configFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), nameof(Xylem.Common.Hardware.WaterMeter.Genesis), ProgramConfig.SerialConfigFileName);

            if (!File.Exists(configFile))
            {
                configFile = Path.Combine(ProgramConfig.SerialConfigFileName);
                if (!File.Exists(configFile))
                {
                    return false;
                }
            }
            var tr = new StreamReader(configFile);
            var slotConfigList = JsonConvert.DeserializeObject<SlotConfig[]>(tr.ReadToEnd());

            foreach (var tMeter in slotConfigList)
            {
                if (tMeter.Type == SlotType.TemperatureMeter)
                {
                    TempMeters.Add(tMeter.Slot);
                }
                else
                {
                    Meters.Add(tMeter.Slot);
                }

            }

            return true;

        }

        public void PrepareActionAuto(Int32 slotCount, String cultureStr)
        {

            internalPrepareAction(slotCount, cultureStr);
        }

        private void internalPrepareAction(int slotCount, string cultureStr)
        {
            try
            {


                if (TestsetuptContainer == null)
                {
                    TestsetuptContainer = new TestSetupContainer();
                    TestsetuptContainer.TempSouce = Enums.TempSouceType.PtOverSps;
                    TestsetuptContainer.ProductionMode = false;

                    TestsetuptContainer.meterTestSettings = new MeterTestSettings[slotCount];
                    TestsetuptContainer.meterTestResults = new MeterTestResults[slotCount];
                }


                var numberOfPaths = (TestsetuptContainer.AllChanelsRequired ? 3 : 1);

                _logger.Info($"PrepareAction [numberOfPaths  = {numberOfPaths},slotCount  = {slotCount},cultureStr  = {cultureStr}, size = { TestsetuptContainer.MeterSize}]");
                var meters = new List<Int32>();
                var tempMeters = new List<Int32>();

                loadTempMetersConfig(out meters, out tempMeters);

                var s = new PreAdjustmentSettingsContainer(numberOfPaths, meters.ToArray(), cultureStr, tempMeters.ToArray(), TestsetuptContainer.MeterSize);
                switch (TestsetuptContainer.TempSouce)
                {
                    case Enums.TempSouceType.ManualInput:
                        s.SetTempUseManualInput(true);
                        s.SetTempUsePtOverSps(false);
                        break;
                    case Enums.TempSouceType.PtOverSps:
                        s.SetTempUsePtOverSps(true);
                        break;
                    case Enums.TempSouceType.TempFlansh:
                        s.SetTempUseTempFlansh(true);
                        s.SetTempUsePtOverSps(false);
                        break;
                    default:
                        break;
                }



                // s.TempSouce = TestsetuptContainer.TempSouce;
                _logger.Info($"SetSettings [{s.ToString()}]");
                wrappedControl.SetSettings(s);

                s.Production = TestsetuptContainer.ProductionMode;


                foreach (var item in TestsetuptContainer?.meterTestSettings.Where(f => f != null && f.PreAdjustment && (!string.IsNullOrEmpty(f.SerialNr) && f.SerialNr != "-")))
                {
                    EnableMeter(item.Slot, true, item.SerialNr);
                }
                Mode = Xylem.Common.Hardware.WaterMeter.WaterMeterCore.MeterTypes.Cordonel;

                if (TestsetuptContainer.meterTestSettings.Any(a => a != null && a.meterType == Xylem.Common.Hardware.WaterMeter.WaterMeterCore.MeterTypes.MagFlux))
                {
                    Mode = Xylem.Common.Hardware.WaterMeter.WaterMeterCore.MeterTypes.MagFlux;
                }

            }
            catch (Exception ex)
            {
                _logger.Fatal(ex);
                MessageBox.Show($"FATAL internalPrep {ex.Message}");
            }
        }
        public void PrepareAction(Int32 slotCount, String cultureStr)
        {

            internalPrepareAction(slotCount, cultureStr);
        }

        public void EnableMeter(Int32 slot, Boolean Enabled, string Srn)
        {
            try
            {
                wrappedControl.EnableMeter(slot, Enabled, Srn);
            }
            catch (Exception ex)
            {
                _logger.Fatal(ex);
                MessageBox.Show($"FATAL EnableMeter {ex.Message}");
            }
        }

        public void StartAction()
        {
            try
            {
                if (Mode == MeterTypes.Cordonel)
                {


                    foreach (var item in TestsetuptContainer?.meterTestSettings)
                    {
                        if (item != null && item.PreAdjustment)
                        {
                            wrappedControl.EnableMeter(item.Slot, true, item.SerialNr);
                        }
                    }

                    wrappedControl.AutoStart();
                }
                else if (Mode == MeterTypes.MagFlux)
                {
                    MessageBox.Show("Start MagFlux ZeroFlow");
                    var  meterBatch = new MeterBatch();

                    foreach (var item in TestsetuptContainer?.meterTestSettings)
                    {
                        if (item != null && item.PreAdjustment && item.meterType == MeterTypes.MagFlux)
                        {
                            var newMeter = new MagFluxMeter();
                            newMeter.SetupFromConfigFile(item.Slot);
                            newMeter.Login();
                            newMeter.SerialNumber = item.SerialNr;

                            meterBatch.AddMeter(newMeter);
                            newMeter.InitCalibration();
                        }
                    }

                    meterBatch.MetersStartMeasurement();
                    var testTime = 60;
                    var ZeroOffsetTime = DateTimeOffset.UtcNow.AddSeconds(testTime);
                    while (ZeroOffsetTime > DateTimeOffset.UtcNow)
                    {
                        Thread.Sleep(1000);
                    }
                    meterBatch.MetersStopMeasurement();
                    ZeroOffsetTime = DateTimeOffset.UtcNow.AddSeconds(10);
                    while (ZeroOffsetTime > DateTimeOffset.UtcNow)
                    {
                        Thread.Sleep(1000);
                    }

                    var c = TestsetuptContainer.meterTestSettings.Count();

                     TestsetuptContainer.meterTestResults = new MeterTestResults[c];
                    for (int i = 0; i < c; i++)
                    {
                        TestsetuptContainer.meterTestResults[c] = new MeterTestResults();
                        TestsetuptContainer.meterTestResults[c].Results = new List<Xylem.Common.Hardware.WaterMeter.DataPackages.MeasurementRecords.FlowDeviations>();
                    }
                    

                    foreach (var meter in meterBatch.ListOfMeters)
                    {
                       var resU = meter.GetMainMeasurementResult(0, testTime);
                        
                        TestsetuptContainer.meterTestResults[meter.Slot - 1].meterType = MeterTypes.MagFlux;
                        TestsetuptContainer.meterTestResults[meter.Slot - 1].Slot = meter.Slot;
                        TestsetuptContainer.meterTestResults[meter.Slot - 1].SerialNr = meter.SerialNumber;
                        TestsetuptContainer.meterTestResults[meter.Slot - 1].Results.Add(new Xylem.Common.Hardware.WaterMeter.DataPackages.MeasurementRecords.FlowDeviations() { RefTimeS = testTime, MeasuredRefFlowQmPerH = 0, RequierdTimeS = testTime, RequierdFlowQmPerH = 0, MeasuredDutFlowQmPerH = resU.DutFlowRateCmPh.Value, DutTimeS = resU.DutTimeS });
                    }


                }
            
            }
            catch (Exception ex)
            {
                _logger.Fatal(ex);
                MessageBox.Show($"FATAL Start Action {ex.Message}");
                pollingAction = PollingAction.IsOnError;
            }
            finally
            {

            }
        }

        public void SetFlushIsDone()
{
    wrappedControl?.SetFlushIsDone();
    pollingAction = PollingAction.IsBusy;

}
public void SetTestBenchTemp(double Temp)
{
    wrappedControl?.SetTestBenchTemp(Temp);
    pollingAction = PollingAction.IsBusy;

}
public PollingAction GetPollingAction()
{
    return pollingAction;
}



/// <summary> 
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{

    if (wrappedControl != null)
    {
        wrappedControl.CloseConnections();
        wrappedControl.Dispose();
    }


    if (disposing && (components != null))
    {
        components.Dispose();
    }
    base.Dispose(disposing);
}

public bool GetMeterIsDone(int Slot)
{
    if (MetersFinallyPassed.Contains(Slot))
    {
        return true;
    }
    return false;
}

public void SetTestSetupContainer(dynamic vbContainer)
{
    if (vbContainer is TestSetupContainer container)
    {
        StringBuilder sb = new StringBuilder();

        sb.AppendLine($"WatingForDecision={container.WatingForDecision}");
        sb.AppendLine($"TempSouce={container.TempSouce}");
        sb.AppendLine($"MeterSize={container.MeterSize}");
        sb.AppendLine($"DelayInSBeforStart={container.DelayInSBeforStart}");
        sb.AppendLine($"AllChanelsRequired={container.AllChanelsRequired}");
        sb.AppendLine($"ProductionMode={container.ProductionMode}");


        foreach (var item in container.meterTestSettings)
        {
            if (item == null)
            {
                continue;
            }
            sb.AppendLine($"Slot={item.Slot}");
            sb.AppendLine($"SerialNr={item.SerialNr}");
            sb.AppendLine($"FlowTesting={item.FlowTesting}");
            sb.AppendLine($"PreAdjustment={item.PreAdjustment}");
            sb.AppendLine($"FlowAdjustment={item.FlowAdjustment}");
            sb.AppendLine($"FlowAdjustmentTarget={item.FlowAdjustmentTarget}");
            sb.AppendLine($"FlowAdjustmentTarget={item.meterType}");

        }

        _logger.Info($"SetTestSetupContainer ({sb}) ");
        TestsetuptContainer = vbContainer;
    }
}

        public dynamic GetTestSetupContainer()
        {
            return TestsetuptContainer;
        }
    }
}