using Aitex.Core.Util;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.ClientBase;
using MECF.Framework.Common.DataCenter;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using FurnaceUI.Models;
using FurnaceUI.Views.Recipes;
using System.Windows;
using System.Windows.Media;
using MECF.Framework.Common.CommonData;

namespace FurnaceUI.Views.Operations
{
    public class BoatWaferViewModel : UiViewModelBase
    {
        public string ModuleName { get; set; }
        public ObservableCollection<ObservableCollection<BoatWaferItem>> ListBoatWafers { get; set; }

        private ObservableCollection<BoatWaferItem> _boatWafers;
        public ObservableCollection<BoatWaferItem> BoatWafers
        {
            get { return _boatWafers; }
            set
            {
                _boatWafers = value;
                NotifyOfPropertyChange("BoatWafers");
            }
        }

        private SolidColorBrush _DefaultdBk = new SolidColorBrush(Colors.White);

        private SolidColorBrush _PBk = new SolidColorBrush(Colors.LightGreen);

        private SolidColorBrush _SDBk = new SolidColorBrush(Colors.SkyBlue);

        private SolidColorBrush _EDBk = new SolidColorBrush(Colors.LightSeaGreen);

        //private SolidColorBrush _MBk = new SolidColorBrush(Colors.LightSeaGreen);
        private SolidColorBrush _MBk = new SolidColorBrush(Colors.Orange);

        private int _boatSlotCount;

        private int _cassetteSlotCount = 25;

        private int _boatPWaferCount;
        public int BoatPWaferCount
        {
            get => _boatPWaferCount;
            set
            {
                _boatPWaferCount = value;
                NotifyOfPropertyChange(nameof(BoatPWaferCount));
            }
        }

        private int _boatMWaferCount;
        public int BoatMWaferCount
        {
            get => _boatMWaferCount;
            set
            {
                _boatMWaferCount = value;
                NotifyOfPropertyChange(nameof(BoatMWaferCount));
            }
        }

        private int _boatSDWaferCount;
        public int BoatSDWaferCount
        {
            get => _boatSDWaferCount;
            set
            {
                _boatSDWaferCount = value;
                NotifyOfPropertyChange(nameof(BoatSDWaferCount));
            }
        }

        private int _boatEDWaferCount;
        public int BoatEDWaferCount
        {
            get => _boatEDWaferCount;
            set
            {
                _boatEDWaferCount = value;
                NotifyOfPropertyChange(nameof(BoatEDWaferCount));
            }
        }

        private int _boatEmptyWaferCount;
        public int BoatEmptyWaferCount
        {
            get => _boatEmptyWaferCount;
            set
            {
                _boatEmptyWaferCount = value;
                NotifyOfPropertyChange(nameof(BoatEmptyWaferCount));
            }
        }

        private string _boatAllWaferCount;
        public string BoatAllWaferCount
        {
            get => _boatAllWaferCount;
            set
            {
                _boatAllWaferCount = value;
                NotifyOfPropertyChange(nameof(BoatAllWaferCount));
            }
        }

        [Subscription("Stocker1.LotID")]
        public string Stocker1LotID { get; set; }

        public BoatWaferViewModel()
        {
            ModuleName = "PM1";
            _boatSlotCount = (int)QueryDataClient.Instance.Service.GetConfig("Boat.SlotCount");
            //_cassetteSlotCount = (int)QueryDataClient.Instance.Service.GetConfig("System.CassetteSlotCount");
            BoatWafers = new ObservableCollection<BoatWaferItem>();
            for (int i = 0; i < _boatSlotCount; i++)
            {
                BoatWaferItem item = new BoatWaferItem() { Slot = i + 1, Description = "" };
                BoatWafers.Add(item);
            }

            for (int i = 0; i < _boatSlotCount; i++)
            {
                string waferType = BoatWafers[i].Description;
                switch (waferType)
                {
                    case "P":
                        BoatWafers[i].BkColor = _PBk;
                        break;
                    case "M":
                        BoatWafers[i].BkColor = _MBk;
                        break;
                    case "SD":
                        BoatWafers[i].BkColor = _SDBk;
                        break;
                    case "ED":
                        BoatWafers[i].BkColor = _EDBk;
                        break;
                    default:
                        BoatWafers[i].BkColor = _DefaultdBk;
                        break;
                }
            }

            ListBoatWafers = SplitBoatWafersByLength(_cassetteSlotCount);
        }

        private ObservableCollection<ObservableCollection<BoatWaferItem>> SplitBoatWafersByLength(int iLength)
        {
            ObservableCollection<ObservableCollection<BoatWaferItem>> obsRet = new ObservableCollection<ObservableCollection<BoatWaferItem>>();
            int iCount = BoatWafers.Count / iLength;
            int iRemain = BoatWafers.Count % iLength;
            for (int i = 0; i < iCount; i++)
            {
                obsRet.Add(new ObservableCollection<BoatWaferItem>(BoatWafers.ToList().GetRange(i * iLength, iLength)));
            }
            if (iRemain > 0) obsRet.Add(new ObservableCollection<BoatWaferItem>(BoatWafers.ToList().GetRange(iCount * iLength, iRemain)));
            return obsRet;
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            RefreshBoatDataTask();
            RefreshBoatWafers();
        }

        private void RefreshBoatDataTask()
        {
            var wafers = ModuleManager.ModuleInfos[ModuleName].WaferManager.Wafers;

            if (wafers != null)
            {
                int iIndex = wafers.Count - 1;
                for (int i = 0; i < wafers.Count; i++)
                {
                    if (wafers[i].WaferStatus != 0)
                    {
                        BoatWafers[iIndex].Description = $"{wafers[i].WaferType}-{wafers[i].SourceName}";
                        switch (wafers[i].WaferType.ToString())
                        {
                            case "P":
                                BoatWafers[iIndex].BkColor = _PBk;
                                break;
                            case "M":
                                BoatWafers[iIndex].BkColor = _MBk;
                                break;
                            case "SD":
                                BoatWafers[iIndex].BkColor = _SDBk;
                                break;
                            case "ED":
                                BoatWafers[iIndex].BkColor = _EDBk;
                                break;
                            default:
                                BoatWafers[iIndex].BkColor = _DefaultdBk;
                                break;
                        }
                    }
                    else
                    {
                        BoatWafers[iIndex].Description = "";
                        BoatWafers[iIndex].BkColor = _DefaultdBk;
                    }
                    iIndex--;
                }
            }

            ListBoatWafers = SplitBoatWafersByLength(_cassetteSlotCount);
        }

        private void RefreshBoatWafers()
        {
            var wafers = ModuleManager.ModuleInfos["PM1"].WaferManager.Wafers.Reverse().ToList();
            int NumberP = 0, NumberM = 0, NumberSD = 0, NumberED = 0, NumberT = 0, NumberXD = 0;
            for (int i = 0; i < wafers.Count; i++)
            {
                if (ModuleManager.ModuleInfos["PM1"].WaferManager.Wafers.Count > i)
                {
                    var wafer = wafers[i];
                    if (wafer.WaferStatus != 0)//empty
                    {
                        switch (wafer.WaferType.ToString())
                        {
                            case "P":
                                NumberP++;
                                break;
                            case "M":
                                NumberM++;
                                break;
                            case "SD":
                                NumberSD++;
                                break;
                            case "ED":
                                NumberED++;
                                break;
                        }
                    }
                }
            }
            BoatPWaferCount = NumberP;
            BoatMWaferCount = NumberM;
            BoatSDWaferCount = NumberSD;
            BoatEDWaferCount = NumberED;
            BoatEmptyWaferCount = _boatSlotCount - BoatPWaferCount - BoatMWaferCount - BoatSDWaferCount - BoatEDWaferCount;
            BoatAllWaferCount = $"{BoatPWaferCount + BoatMWaferCount + BoatSDWaferCount + BoatEDWaferCount}/{_boatSlotCount}";
        }
    }

    public class BoatWaferItem : NotifiableItem
    {
        private int _slot;
        public int Slot
        {
            get => _slot;
            set
            {
                _slot = value;
                InvokePropertyChanged("Slot");
            }
        }

        private string _description;
        public string Description
        {
            get => _description;
            set
            {
                _description = value;
                InvokePropertyChanged("Description");
            }
        }

        private bool _hasWafer;
        public bool HasWafer
        {
            get => _hasWafer;
            set
            {
                _hasWafer = value;
                InvokePropertyChanged("HasWafer");
            }
        }

        private bool _noWafer;
        public bool NoWafer
        {
            get => _noWafer;
            set
            {
                _noWafer = value;
                InvokePropertyChanged("NoWafer");
            }
        }

        private SolidColorBrush _bkColor;
        public SolidColorBrush BkColor
        {
            get => _bkColor;
            set
            {
                _bkColor = value;
                InvokePropertyChanged("BkColor");
            }
        }
    }
}