using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using Logic.ProductionToProductMapper.Cordonel;
using Newtonsoft.Json;
using ProductionUiCordonelLegacy.Data;
using Xylem.Common.CommonCore.Configuration;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts;
using Xylem.Common.Logic.ProductionOrderCore.OrderData;
using Xylem.Common.Logic.SoftwareAccessHelper;
using MessageBox = System.Windows.Forms.MessageBox;

namespace ProductionUiCordonelLegacy.Model
{
    public class PickingMultiModeViewModel : BaseMultiModeChildViewModel
    {

        private Boolean inputIsEnabled;
        public Boolean InputIsEnabled
        {
            get => inputIsEnabled;
            set
            {
                inputIsEnabled = value;
                NotifyPropertyChanged();
            }
        }


        private Boolean locked;
        public PickingMultiModeViewModel(String ctrName, Int32 slotNR, List<String> barcodeTrigger, Int32? stationID = null) : base(ctrName, slotNR, barcodeTrigger, stationID, false)
        {
            VisibilityPicking = Visibility.Visible;
            MeterDetectedHandler += PickingMultiModeViewModel_MeterDetectedHandler;
        }

        private void PickingMultiModeViewModel_MeterDetectedHandler(Object sender, EventArgs e)
        {

        }



        public override Boolean SlotIsLocked()
        {
            return locked;
        }
        public override void InputText(String text)
        {
            Order = text;
            ReloadData();
            TextForceUpdate();
        }
        internal void ReloadData()
        {

            Task.Run((Action)(() =>
            {
                try
                {
                    if (!locked && !string.IsNullOrEmpty(Order) && Order.Length > 6 && int.TryParse(Order, out var orderNR))
                    {

                        var str = LocalWebRequest.GetRequest($"{ServiceUrls.GenesisFinalCheckServiceUrl()}GetOrderOverview?ProductionOrderNumber={orderNR}");
                        var OrderOverView = JsonConvert.DeserializeObject<OrderOverViewCordonel>(str);
                        var doneCount = OrderOverView.AssignedPicking;
                        if (OrderOverView.Count == OrderOverView.AssignedPicking)
                        {

                            UpdatePickingUi("Order is already completed", StatusColor, "Input a new Ordernumber", 0, 0);
                            locked = false;
                            return;
                        }

                        str = LocalWebRequest.GetRequestWithError($"{ServiceUrls.GenesisFinalCheckServiceUrl()}GetOrderDetails?ProductionOrderNumber={orderNR}&CheckPcbId={CurrentMeter.PcbId}", out var retCode, 15000);

                        if (retCode == 417)
                        {
                            MessageBox.Show(@"NO radio parameter found");
                        }

                        if (OrderOverView.Count == OrderOverView.AssignedPicking)
                        {

                            UpdatePickingUi("Order is already completed", StatusColor, "Input a new Ordernumber", 0, 0);
                            locked = false;
                            return;
                        }

                        var OrderDteails = JsonConvert.DeserializeObject<PickingCompareItem>(str);


                        if (CurrentMeter != null)
                        {
                            try
                            {


                                locked = true;
                                //Init(CurrentMeter, new Dictionary<uint, uint>(), OrderDteails.FrequencyIndicator, OrderDteails.MeterSize, OrderDteails.PressurePresent);


                                var a = new Dictionary<UInt32, UInt32>();
                                a.Add(0, 486);
                                a.Add(15, 287);
                                if (OrderDteails.FrequencyIndicator == 868)
                                {
                                    a.Add(24, 1067);
                                }
                                else
                                {
                                    a.Add(24, 1066);
                                }

                                Init(CurrentMeter, a, OrderDteails.FrequencyIndicator, OrderDteails.MeterSize, OrderDteails.PressurePresent);


                                var r = Run(CurrentMeter.PcbId, orderNR.ToString());

                                if (r)
                                {
                                    doneCount = doneCount + 1;
                                }
                                locked = false;
                                UpdatePickingUi("Start checking meter", StatusColor, orderNR.ToString(), OrderOverView.Count, doneCount);
                            }
                            catch (Exception ex)
                            {
                                Log(ex.Message);
                            }
                            finally
                            {
                                locked = false;
                            }
                        }
                    }
                    else
                    {
                        UpdatePickingUi("Please input a valid order number", StatusColor, "no valid order!", 0, 0);

                    }
                }
                catch (Exception ex)
                {
                    Log(ex.Message);
                }
            }));
        }

        private void UpdatePickingUi(String state, Brush StateColor, String order, Int32 toDo, Int32 done)
        {
            Message = state;
            Order = order;
            ToDo = toDo;
            Done = done;
            OnUpdateUi?.Invoke(null, EventArgs.Empty);
            //if (true)
            //{

            //}
            //    lblStatus.Content = state;
            //    lblStatus.Background = StateColor;
            //    lblPickingOrder.Content = $"{Order}({Done}/{toDo}";
            //    txtHiddenInput.Focus();
            //    if (Done > 0 && Done >= toDo)
            //    {
            //        MessageBox.Show("Order is Finish");
            //        txtOrderNr.Text = "";
            //        lblStatus.Content = "Please input a new order number";
            //    }

            //}));

        }
        //private void RefreshPicking()
        //{

        //    tbarOrder.Visibility = Visibility.Visible;
        //    if (!string.IsNullOrEmpty(txtOrderNr.Text))
        //    {
        //        lblPickingOrder.Content = orderString;


        //    }
        //    else
        //    {
        //        UpdatePickingUi("Please input a valid order number", PickingData.StatusColor, "no valid order!", 0, 0);
        //    }
        //}

        public event EventHandler OnDataChanged;
        public event EventHandler OnUpdateUi;
        public new event PropertyChangedEventHandler PropertyChanged;

        private GenesisMeter currentMeter;

        public ObservableCollection<IPickingResultData> Data
        {
            get; set;
        }

        private OverallStatus status = OverallStatus.NoDetect;
        private OverallStatus Status
        {
            get => status;
            set
            {
                status = value;
                OnDataChanged?.Invoke(value.GetHashCode(), EventArgs.Empty);

            }
        }
        public String Message
        {
            get; set;
        }
        private enum OverallStatus
        {
            NoDetect,
            CheckingIsRunning,
            CheckingIsDone,
            CheckingIsNoMatch,
            CheckingIsHasError,
        }
        public String StatusText
        {
            get
            {
                switch (Status)
                {
                    case OverallStatus.NoDetect:
                        return "Wait for meter";
                    case OverallStatus.CheckingIsRunning:
                        return "Is checking, please wait";
                    case OverallStatus.CheckingIsDone:
                        return "Succsesfull check next Pcb";
                    case OverallStatus.CheckingIsNoMatch:
                        return "Check has mismatch, this PCB cannot be used!";
                    default:
                        return "Check has errors, this PCB cannot be used!";
                }

            }
        }

        public Brush StatusColor
        {
            get
            {
                switch (Status)
                {
                    case OverallStatus.NoDetect:
                        return (SolidColorBrush)new BrushConverter().ConvertFromString("White");
                    case OverallStatus.CheckingIsRunning:
                        return (SolidColorBrush)new BrushConverter().ConvertFromString("Yellow");
                    case OverallStatus.CheckingIsDone:
                        return (SolidColorBrush)new BrushConverter().ConvertFromString("Green");
                    case OverallStatus.CheckingIsNoMatch:
                        return (SolidColorBrush)new BrushConverter().ConvertFromString("Red");
                    default:
                        return (SolidColorBrush)new BrushConverter().ConvertFromString("DarkRed");
                }
            }
        }

        public Int32 ToDo
        {
            get; private set;
        }
        public Int32 Done
        {
            get; private set;
        }

        public void Init(GenesisMeter meter, Dictionary<UInt32, UInt32> checkAppsIdVersion, UInt32 Frequency, UInt32 MeterSize, Boolean PressurePresent)
        {


            currentMeter = meter;
            var data = new List<IPickingResultData>();

            data.Add(new PickingResultCustomCheckData(delegate
            {

                meter.Login();
                meter.SetProcessState(DisplayCodes.PickingStarted);
                return new PickingItemCheckReturn { Result = true, Msg = "done" };

            })
            {
                Index = data.Count, Ident = "Login", CheckText = "Try to access Meter", HasError = false, Result = null,
                CurrentValueText = "-"
            });

            data.Add(new PickingResultRegisterData
            {
                ReadMeter = meter, Index = data.Count, Ident = "Check Radio", CheckText = $"{Frequency}MHz",
                CompareObject = Frequency, CurrentValueText = "none", HasError = false, Result = null,
                RegisterIdent = "SENSUSRADIO_FrequencyIndicator"
            });


            data.Add(new PickingResultRegisterData
            {
                ReadMeter = meter, Index = data.Count, Ident = "MeterSize",
                CheckText = "DN40-50", CompareObject = MeterSize, CurrentValueText = "none", HasError = false,
                Result = null, RegisterIdent = "GENESISFLOW_MeterSize"
            });

            data.Add(new PickingResultRegisterData
            {
                ReadMeter = meter, Index = data.Count, Ident = "Pressure",
                CheckText = "Pressure Sensor", CompareObject = PressurePresent, CurrentValueText = "-", HasError = false,
                Result = null, RegisterIdent = "METROLOGYASST_PressurePresent"
            });


            foreach (var item in checkAppsIdVersion)
            {
                data.Add(new PickingResultCustomCheckData(delegate
                {
                    try
                    {
                        var MeterFWApp = meter.MeterAppListVersion.First(a => item.Key == a.AppId);
                        if (MeterFWApp.Version != item.Value)
                        {
                            return new PickingItemCheckReturn { Result = false, Msg = MeterFWApp.StrVersion };
                        }
                        return new PickingItemCheckReturn { Result = true, Msg = MeterFWApp.StrVersion };
                    }
                    catch (Exception)
                    {
                        return new PickingItemCheckReturn { Result = false, Msg = "error" };
                    }

                })
                {
                    Index = data.Count, Ident = $"Check AppId {item.Key}", CheckText = $"Version {item.Value}",
                    HasError = false, Result = null, CurrentValueText = "-"
                });

            }

            data.Add(new PickingResultCustomCheckData(delegate
                {
                    try
                    {
                        meter.WriteRegister("METROLOGYASST_StoreConfiguration", 1);
                        Thread.Sleep(100);
                        var storeRet = meter.ReadRegister("METROLOGYASST_StoreConfiguration");
                        if (storeRet.All(a => a.Equals(0)))
                        {
                            return new PickingItemCheckReturn { Result = true, Msg = "Filesystem OK" };
                        }

                        return new PickingItemCheckReturn { Result = false, Msg = "Filesystem corrupt" };

                    }
                    catch (Exception)
                    {
                        return new PickingItemCheckReturn { Result = false, Msg = "error" };
                    }

                })
            {
                Index = data.Count, Ident = "Check Filesystem", CheckText = "Check Filesystem", HasError = false, 
                Result = null, CurrentValueText = "checking"
            });
            
            Status = OverallStatus.CheckingIsRunning;
            ChangeDataData(data);
        }
        private void ChangeDataData(List<IPickingResultData> data)
        {
            Data = new ObservableCollection<IPickingResultData>(data);
            OnDataChanged?.Invoke(Data, EventArgs.Empty);
        }

        public Boolean Run(String pcbID, String OrderNr)
        {
            var tmpData = Data.ToList();
            foreach (var item in tmpData.Where(a => !a.Result.HasValue).OrderBy(a => a.Index))
            {
                var result = item.Action.Invoke();
                item.Result = result.Result;
                item.CurrentValueText = result.Msg;
                ChangeDataData(tmpData);
            }

            if (tmpData.All(a => !a.HasError && a.Result.HasValue && a.Result.Value))
            {
                currentMeter.SetProcessState(DisplayCodes.PickingTested);
                var url = $"{ServiceUrls.MeterProcessStateUrl()}SetPickingState?PcbID={pcbID}&FertigungsauftragsNr={OrderNr}";
                var RetString = LocalWebRequest.PostRequestAsyncAndGetContent(url);

                if (bool.TryParse(RetString, out var result))
                {
                    Status = OverallStatus.CheckingIsDone;
                    return result;

                }

                Status = OverallStatus.CheckingIsHasError;

                return false;

            }

            currentMeter.SetProcessState(DisplayCodes.PickingFailed);
            if (tmpData.All(a => a.HasError))
            {
                Status = OverallStatus.CheckingIsHasError;
            }
            else
            {
                Status = OverallStatus.CheckingIsNoMatch;
            }

            return false;
        }

        internal void Empty()
        {
            Status = OverallStatus.NoDetect;
            ChangeDataData(new List<IPickingResultData>());
        }

        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChanged?.Invoke(this, e);
        }
    }
}