using CordonelAssemblyLine.Data;
using CordonelAssemblyLine.Event;
using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Timers;
using Xylem.Common.CommonCore.Configuration;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Logic.ProductionOrderCore.TestResults;
using Xylem.Common.Logic.SoftwareAccessHelper;
using Xylem.Common.Utils.Logging;

namespace CordonelAssemblyLine.Model
{
    public class LeakViewModel : INotifyPropertyChanged
    {
        public event EventHandler<StringArgs> OnStoreDone;
        public event EventHandler MeterDetectedHandler;
        protected virtual void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        public event PropertyChangedEventHandler PropertyChanged;


        private PressureResultDataNotifyable result = new PressureResultDataNotifyable();
        public PressureResultDataNotifyable Result
        {
            get { return result; }
            set
            {
                result = value;
                NotifyPropertyChanged(nameof(Result));
            }
        }
        private string testerName;
        public string TesterName
        {
            get { return testerName; }
            set
            {
                testerName = value;
                NotifyPropertyChanged(nameof(TesterName));
            }
        }

        private bool inputIsEnabled = false;
        public bool InputIsEnabled
        {
            get { return inputIsEnabled; }
            set
            {
                inputIsEnabled = value;
                NotifyPropertyChanged(nameof(InputIsEnabled));
            }
        }

        private int intervalWithoutDetect = 1000;
        private int intervalWithDetect = 10000;
        private string _currentPcbID;
        private MeterBatch Batch = new MeterBatch();
        public GenesisMeter CurrentMeter { get; private set; }

        public bool Locked { get; set; } = false;
        public int? StationID { get; set; } = null;
        private string toolTip;
        public string ToolTipInput
        {
            get
            {
                return toolTip;
            }
            set
            {
                toolTip = value;

                NotifyPropertyChanged(nameof(ToolTipInput));
            }
        }

        public string CurrentPcbID
        {
            get
            {
                return _currentPcbID;
            }
            set
            {
                _currentPcbID = value;

                NotifyPropertyChanged(nameof(CurrentPcbID));
            }
        }
        private Timer tmrAutoDetect;

        public LeakViewModel(int slotNR, int? stationID = null)
        {
            _logger = NLogHelper.CreateOrGetLogger("ProductionUI");
            StationID = stationID;
            SlotNr = slotNR;
            tmrAutoDetect = new Timer(intervalWithoutDetect);
            tmrAutoDetect.Elapsed += TmrAutoDetect_Elapsed;
            tmrAutoDetect.Enabled = true;

            ToolTipInput = $"Unterstützte Eingabeformate: {System.Environment.NewLine} " +
                            $"2,00E-07 { System.Environment.NewLine} " +
                            $"2E-07 { System.Environment.NewLine} " +
                            $"2x10-7 { System.Environment.NewLine} " +
                            $"2*10^-7 { System.Environment.NewLine} " +
                            "0,0000002";


        }

        public bool isHydraulicStaion()
        {

            if (!StationID.HasValue || StationID.Value == 1)
            {
                return false;
            }
            return true;
        }
        private readonly ILogger _logger;
        private readonly int SlotNr;

        public void Log(string txt)
        {
            _logger?.Info(txt);
        }
        private bool Detect()
        {

            Log("Start Detect");
            bool hasDetect = false;
            if (string.IsNullOrEmpty(CurrentPcbID) || CurrentMeter == null)
            {
                Batch = new MeterBatch();
                var tryMeter = new GenesisMeter();
                try
                {
                    tryMeter.SetupFromConfigFile(SlotNr);
                    Batch.AddMeter(tryMeter);
                    tryMeter.Logout();
                    Log("Try to get PcbID");
                    CurrentPcbID = tryMeter.GetPcbId();

                    hasDetect = !string.IsNullOrEmpty(CurrentPcbID);
                    CurrentMeter = tryMeter;
                    if (hasDetect)
                    {
                        MeterDetectedHandler?.Invoke(CurrentMeter, EventArgs.Empty);
                        Log($"New PcbID detected {CurrentPcbID}");
                    }
                    else
                    {
                        Log($"No Meter found");
                        DisposeAllConnections();
                    }

                }
                catch (Exception e)
                {
                    Log($"Error occur.{ Environment.NewLine} {e.Message}");
                }

            }
            else
            {
                Log("Check if Meter is still connected");
                var ret = CurrentMeter.GetPcbId();
                if (string.IsNullOrEmpty(ret) || ret != CurrentPcbID)
                {
                    Log("Meter connection lost");
                    hasDetect = false;
                    DisposeAllConnections();

                    CurrentPcbID = "";
                }
                else
                {
                    Log("Meter is still connected");
                    hasDetect = true;
                }
            }
            return hasDetect;
        }


        private void DisposeAllConnections()
        {
            if (Batch != null)
            {
                MeterDetectedHandler?.Invoke(null, EventArgs.Empty);
                Batch.RemoveAllMeters();
                if (CurrentMeter != null)
                {
                    CurrentMeter.Dispose();
                }
                Batch.Dispose();
            }

        }

        public void Dispose()
        {
            DisposeAllConnections();
        }

        public void TmrAutoDetect_Elapsed(object sender, EventArgs e)
        {
            tmrAutoDetect.Enabled = false;
            var hasDetect = Detect();
            if (hasDetect)
            {
                tmrAutoDetect.Interval = intervalWithDetect;
            }
            else
            {
                tmrAutoDetect.Interval = intervalWithoutDetect;
            }
            tmrAutoDetect.Enabled = true;
        }
        internal void ReloadData(bool reset)
        {

            if (Result != null && Result.PcbId != CurrentPcbID)
            {
                InputIsEnabled = false;
                Result = new PressureResultDataNotifyable() { Remark = "loading", Testpoints = new ObservableCollection<PressureTestPoints>(), PcbId = "" };
                Task<PressureResultDataNotifyable>.Run(() =>
                {
                    try
                    {
                        var url = ServiceUrls.MeterProcessStateUrl();
                        url = url + $"GetPressureStateDetailed?PcbId={CurrentPcbID}&TopCount=1";
                        var tmp = 0;
                        var retStr = LocalWebRequest.GetRequestWithError(url, out tmp);
                        if (tmp != 200)
                        {
                            throw new ApplicationException("Keinen Auftrag gefunden. Kommissionierung prüfen!");
                        }
                        var pressureResultData = JsonConvert.DeserializeObject<List<PressureResultData>>(retStr);
                        if (!pressureResultData.Any())
                        {
                            return new PressureResultDataNotifyable();
                        }
                        return new PressureResultDataNotifyable(pressureResultData.First());
                    }
                    catch (Exception ex)
                    {
                        Log(ex.Message);
                        return new PressureResultDataNotifyable();
                    }

                }).ContinueWith((a) =>
                {
                    if (a == null)
                    {

                    }
                    else
                    {
                        var res = a.Result;
                        res.PcbId = CurrentPcbID;

                        Result = res;
                        InputIsEnabled = true;
                    }

                }

                    );

            }
        }


        internal void StoreData(bool successfull)
        {

            if (Result != null && Result.PcbId == CurrentPcbID)
            {
                InputIsEnabled = false;
                var isStored = false;
                Result.TesterName = TesterName;
                Task.Run(() =>
                {
                    var url = ServiceUrls.MeterProcessStateUrl();

                    var status = Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PressureTestedFailed;
                    if (successfull)
                    {
                        status = Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PressureTested;
                    }
                    try
                    {

                        url = url + $"SetPressureStateDetailed";
                        var mutedResult = Result.ToBase();
                        isStored = LocalWebRequest.PostRequestAsync(url, json: mutedResult);
                        if (!isStored)
                        {
                            OnStoreDone?.Invoke(null, new StringArgs("Kann nicht gespeichert werden"));
                            status = Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PressureTestedFailed;
                        }



                        CurrentMeter.Login();
                        CurrentMeter.SetProcessState(status);
                    }
                    catch (Exception ex)
                    {
                        Log(ex.Message);
                        status = Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PressureTestedFailed;
                        OnStoreDone?.Invoke(null, new StringArgs($"Kann nicht gespeichert werden.Fehler: {ex.Message}"));
                    }


                    if (status == Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PressureTested)
                    {
                        OnStoreDone?.Invoke(null, new StringArgs("Ergebnis gespeichert der Zähler weiter bearbeitet werden."));
                        return;
                    }
                    OnStoreDone?.Invoke(null, new StringArgs("Bitte erneut testen oder Linienleitung und QS informieren."));

                });

            }
        }

    }
}