using System;
using System.Collections.Generic;
using System.Diagnostics.Eventing.Reader;
using System.Linq;
using System.Text;
using CordonelPreadjustmentUi.Processes.Itinerary;
using System.Threading;
using static CordonelPreadjustmentUi.PreAdjustmentControl;
using System.Threading.Tasks;

using Xylem.Common.Logic.SoftwareAccessHelper;
using Xylem.Common.CommonCore.Configuration;
using Newtonsoft.Json;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;

namespace CordonelPreadjustmentUi.Processes.Actions
{
    public class SPPreparationProcess : BaseProcess
    {
        public SPPreparationProcess(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)
        {
            var MetersToProcess = MeterStateCtls.Where(e => e.IsEnabled).ToList();

            //MetersToProcess.AddRange(TempMeterStateCtls.Where(e => e.IsEnabled));

            var listOfProcessTask = new List<Task>();

            foreach (var item in TempMeterStateCtls.Where(e => e.IsEnabled))
            {
                listOfProcessTask.Add(new Task<bool>(() =>
                {
                    item.Meter.StartRecordData();
                    return true;
                }));
            }
            foreach (var meterctl in MetersToProcess)
            {
                listOfProcessTask.Add(new Task<bool>(() =>
                {


                    meterctl.Id = string.IsNullOrEmpty(meterctl.Meter.PcbId) ? "Unknown" : $"Pcb:{meterctl.Meter.PcbId}";
                    meterctl.Meter.StartRecordData();

                   

                    Boolean Ok = false;


                    if (pp.Setting.NumberOfPaths > 0)
                    {
                        Ok = WriteRegisterSafe(meterctl.Meter, "Calibration factor1", Register.Genesisflow.CalFactor1, pp.Setting.CalFactor1);
                        if (CheckAbort(Ok, meterctl)) { return Ok; }
                    }
                    if (pp.Setting.NumberOfPaths > 1)
                    {
                        Ok = WriteRegisterSafe(meterctl.Meter, "Calibration factor2", Register.Genesisflow.CalFactor2, pp.Setting.CalFactor2);
                        if (CheckAbort(Ok, meterctl)) { return Ok; }
                    }
                    if (pp.Setting.NumberOfPaths > 2)
                    {
                        Ok = WriteRegisterSafe(meterctl.Meter, "Calibration factor3", Register.Genesisflow.CalFactor3, pp.Setting.CalFactor3);
                        if (CheckAbort(Ok, meterctl)) { return Ok; }
                    }


                    if (pp.Setting.doOffsetTest)
                    {
                        //if (pp.Setting.NumberOfPaths > 0)
                        //{
                            Ok = WriteRegisterSafe(meterctl.Meter, "Zeroflow offset1", Register.Genesisflow.ZeroOffset1, pp.Setting.ZeroOffset1);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                        //}
                        //if (pp.Setting.NumberOfPaths > 1)
                        //{
                            Ok = WriteRegisterSafe(meterctl.Meter, "Zeroflow offset2", Register.Genesisflow.ZeroOffset2, pp.Setting.ZeroOffset2);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                        //}
                        //if (pp.Setting.NumberOfPaths > 2)
                        //{
                            Ok = WriteRegisterSafe(meterctl.Meter, "Zeroflow offset3", Register.Genesisflow.ZeroOffset3, pp.Setting.ZeroOffset3);
                            if (CheckAbort(Ok, meterctl)) { return Ok; }
                        //}

                    }
                    meterctl.Meter.calibrationResult.AddAdditionalLog($"OffsetTestNumberOfLines", pp.Setting.OffsetTestNumberOfLines.ToString());
                    meterctl.Meter.calibrationResult.AddAdditionalLog($"Samplerate", pp.Setting.Samplerate.ToString());


                    Ok = WriteRegisterSafe(meterctl.Meter, "Samplerate", Register.Genesisflow.SampleRate, pp.Setting.Samplerate);
                    if (CheckAbort(Ok, meterctl)) { return Ok; }
                    if (pp.Setting.Production)
                    {
                        Ok = WriteRegisterSafe(meterctl.Meter, "Metersize", Register.Genesisflow.MeterSize, pp.Setting.MeterSize.GetHashCode(), false);
                        if (CheckAbort(Ok, meterctl)) { return Ok; }
                    }
                    else
                    {
                        WriteRegisterSafe(meterctl.Meter, "Metersize", Register.Genesisflow.MeterSize, pp.Setting.MeterSize.GetHashCode(), false);
                        if (CheckAbort(Ok, meterctl)) { return Ok; }
                    }
               

                    Ok = WriteRegisterSafe(meterctl.Meter, "LED mode", Register.Genesisflow.LedMode, pp.Setting.LedMode.GetHashCode());
                    if (CheckAbort(Ok, meterctl)) { return Ok; }

                    Ok = WriteRegisterSafe(meterctl.Meter, "TriggerActive", Register.Genesisflow.TriggerActive, 1, false);
                    if (CheckAbort(Ok, meterctl)) { return Ok; }



                    if (CheckAbort(Ok, meterctl)) { return Ok; }

                    var r = LocalWebRequest.GetRequest($"{ ServiceUrls.GenesisFinalCheckServiceUrl()}GetMetersizeProgrammingData?MeterSize={pp.Setting.MeterSize.GetHashCode()}", 2000);
                    var dt = JsonConvert.DeserializeObject<Dictionary<string, UInt32>>(r);

                    foreach (var item in dt)
                    {
                        Ok = meterctl.Meter.WriteRegisterUnsafe(item.Key, item.Value);
                        if (CheckAbort(Ok, meterctl)) { return Ok; }
                    }


                    return Ok;
                }));

            }
            return listOfProcessTask;

        }
        private static byte[] ReservandFill(byte[] b)
        {
            return b.Reverse().ToArray();

        }

    }



}