using Aitex.Core.Common;
using Aitex.Core.UI.MVVM;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.WaferHolder;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.NetworkInformation;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;

namespace CyberX8_MainPages.ViewModels
{
    public class MaterialMovementViewModel : BindableBase
    {
        #region 常量
        private const int DATAGRIP_ROW_NUM = 24;
        
        #endregion

        #region 内部变量
        #region system
        /// <summary>
        /// rt查询key
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// 时钟
        /// </summary>
        DispatcherTimer _timer;
        /// <summary>
        /// rt查询数据
        /// </summary>
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
        /// <summary>
        /// LayoutCell列表
        /// </summary>
        private ObservableCollection<string> _locationLst;
        #endregion

        #region Common
        /// <summary>
        /// Module
        /// </summary>
        private string _module;
        /// <summary>
        /// MaterialData Collection
        /// </summary>
        private List<ModuleMaterial> _materialDatas;
        /// <summary>
        /// MaterialData Sub Collection1
        /// </summary>
        private ObservableCollection<ModuleMaterial> _materialSubdatas1;
        /// <summary>
        /// MaterialData Sub Collection2
        /// </summary>
        private ObservableCollection<ModuleMaterial> _materialSubdatas2;
        /// <summary>
        /// MaterialData Sub Collection Buffer1
        /// </summary>
        private List<ModuleMaterial> _materialSubdatasBuffer1;
        /// <summary>
        /// MaterialData Sub Collection Buffer2
        /// </summary>
        private List<ModuleMaterial> _materialSubdatasBuffer2;
        /// <summary>
        /// Pre MaterialDatas1
        /// </summary>
        private List<ModuleMaterial> _preMaterialDatas1 = new List<ModuleMaterial>();
        /// <summary>
        /// Pre MaterialDatas2
        /// </summary>
        private List<ModuleMaterial> _preMaterialDatas2 = new List<ModuleMaterial>();
        /// <summary>;
        /// <summary>
        /// From Loaction选择
        /// </summary>
        private string _fromLocation;
        /// <summary>
        /// To Location选择
        /// </summary>
        private string _toLocation;
        /// <summary>
        /// ProcessTransporter是否Busy
        /// </summary>
        private bool _isProcessTransBusy;
        /// <summary>
        /// LoaderTransporter是否Busy
        /// </summary>
        private bool _isLoaderTransBusy;
        /// <summary>
        /// 是否在Auto模式下
        /// </summary>
        private bool _isAutoMode;
        /// <summary>
        /// UpdateLocation按钮是否启用
        /// </summary>
        private bool _isMoveEnable;
        /// <summary>
        /// Remove按钮是否启用
        /// </summary>
        private bool _isRemoveEnable;
        /// <summary>
        /// Selected MaterialData
        /// </summary>
        private ModuleMaterial _selectedMaterialData;
        /// <summary>
        /// Pre Selected MaterialData
        /// </summary>
        private ModuleMaterial _preSelectedMaterialData;
        /// <summary>
        /// Selected MaterialData1
        /// </summary>
        private ModuleMaterial _selectedMaterialData1;
        /// <summary>
        /// Selected MaterialData2
        /// </summary>
        private ModuleMaterial _selectedMaterialData2;
        /// <summary>
        /// Selected ModuleName
        /// </summary>
        private string _selectedModuleName;
        /// <summary>
        /// WaferMove FromSlot列表
        /// </summary>
        private ObservableCollection<int> _fromSlotLst = new ObservableCollection<int>();
        /// <summary>
        /// WaferMove ToSlot列表
        /// </summary>
        private ObservableCollection<int> _toSlotLst = new ObservableCollection<int>();
        /// <summary>
        /// WaferMove Modules列表
        /// </summary>
        private ObservableCollection<ModuleName> _moduleLst = new ObservableCollection<ModuleName>();
        /// <summary>
        /// WaferMove From Module
        /// </summary>
        private ModuleName _fromModule;
        /// <summary>
        /// WaferMove To Module
        /// </summary>
        private ModuleName _toModule;
        /// <summary>
        /// WaferMove To Slot
        /// </summary>
        private int _toSlot;
        /// <summary>
        /// WaferMove From Slot
        /// </summary>
        private int _fromSlot;
        /// <summary>
        /// WaferMove Update按钮是否启用
        /// </summary>
        private bool _isWaferMoveEnable;
        /// <summary>
        /// MaterialDataBuffer
        /// </summary>
        private ModuleMaterial _materialDataBuffer;
        /// <summary>
        /// Grid Selection
        /// </summary>
        private bool _gridSelection;
        #endregion
        #endregion

        #region 属性


        #region Common
        /// <summary>
        /// MaterialData Collection
        /// </summary>
        public List<ModuleMaterial> MaterialDatas
        {
            get { return _materialDatas; }
            set
            {
                SetProperty(ref _materialDatas, value);
            }
        }
        /// <summary>
        /// MaterialData Sub Collection1
        /// </summary>
        public ObservableCollection<ModuleMaterial> MaterialSubdatas1
        {
            get { return _materialSubdatas1; }
            set
            {
                SetProperty(ref _materialSubdatas1, value);
            }
        }
        /// <summary>
        /// MaterialData Sub Collection2
        /// </summary>
        public ObservableCollection<ModuleMaterial> MaterialSubdatas2
        {
            get { return _materialSubdatas2; }
            set
            {
                SetProperty(ref _materialSubdatas2, value);
            }
        }
        /// <summary>
        /// Selected MaterialData
        /// </summary>
        public ModuleMaterial SelectedMaterialData
        {
            get { return _selectedMaterialData; }
            set
            {
                SetProperty(ref _selectedMaterialData, value);
            }
        }
        /// <summary>
        /// Selected MaterialData1
        /// </summary>
        public ModuleMaterial SelectedMaterialData1
        {
            get { return _selectedMaterialData1; }
            set
            {
                SetProperty(ref _selectedMaterialData1, value);
            }
        }
        /// <summary>
        /// Selected MaterialData2
        /// </summary>
        public ModuleMaterial SelectedMaterialData2
        {
            get { return _selectedMaterialData2; }
            set
            {
                SetProperty(ref _selectedMaterialData2, value);
            }
        }
        /// <summary>
        /// Selected ModuleName
        /// </summary>
        public string SelectedModuleName
        {
            get { return _selectedModuleName; ; }
            set
            {
                SetProperty(ref _selectedModuleName, value);
            }
        }
        /// <summary>
        /// LayoutCell列表
        /// </summary>
        public ObservableCollection<string> LocationLst
        {
            get { return _locationLst; }
            set { SetProperty(ref _locationLst, value); }
        }
        /// <summary>
        /// From Location
        /// </summary>
        public string FromLocation
        {
            get { return _fromLocation; }
            set { SetProperty(ref _fromLocation, value); }
        }
        /// <summary>
        /// To Location
        /// </summary>
        public string ToLocation
        {
            get { return _toLocation; }
            set { SetProperty(ref _toLocation, value); }
        }
        /// <summary>
        /// UpdateLocation按钮是否启用
        /// </summary>
        public bool IsMoveEnable
        {
            get { return _isMoveEnable; }
            set { SetProperty(ref _isMoveEnable, value); }
        }
        /// <summary>
        /// Remove按钮是否启用
        /// </summary>
        public bool IsRemoveEnable
        {
            get { return _isRemoveEnable; }
            set { SetProperty(ref _isRemoveEnable, value); }
        }
        /// <summary>
        /// WaferMove FromSlot列表
        /// </summary>
        public ObservableCollection<int> FromSlotLst
        {
            get { return _fromSlotLst; }
            set { SetProperty(ref _fromSlotLst, value); }
        }
        /// <summary>
        /// WaferMove ToSlot列表
        /// </summary>
        public ObservableCollection<int> ToSlotLst
        {
            get { return _toSlotLst; }
            set { SetProperty(ref _toSlotLst, value); }
        }
        /// <summary>
        /// WaferMove Modules列表
        /// </summary>
        public ObservableCollection<ModuleName> ModuleLst
        {
            get { return _moduleLst; }
            set { SetProperty(ref _moduleLst, value); }
        }
        /// <summary>
        /// WaferMove From Module
        /// </summary>
        public ModuleName FromModule
        {
            get { return _fromModule; }
            set { SetProperty(ref _fromModule, value); }
        }
        /// <summary>
        /// WaferMove To Module
        /// </summary>
        public ModuleName ToModule
        {
            get { return _toModule; }
            set { SetProperty(ref _toModule, value); }
        }
        /// <summary>
        /// WaferMove To Slot
        /// </summary>
        public int ToSlot
        {
            get { return _toSlot; }
            set { SetProperty(ref _toSlot, value); }
        }
        /// <summary>
        /// WaferMove To Slot
        /// </summary>
        public int FromSlot
        {
            get { return _fromSlot; }
            set { SetProperty(ref _fromSlot, value); }
        }
        /// <summary>
        /// WaferMove按钮是否启用
        /// </summary>
        public bool IsWaferMoveEnable
        {
            get { return _isWaferMoveEnable; }
            set { SetProperty(ref _isWaferMoveEnable, value); }
        }
        #endregion


        #endregion

        #region 命令
        public ICommand UpdateLocationCommand { get; private set; }
        public ICommand UpdateWaferCommand { get; private set; }
        public ICommand RemoveCommand { get; private set; }
        public ICommand ModuleChangeCommand { get; private set; }
        public ICommand SelectionChangeCommand { get; private set; }

        public ICommand ResetWafersCommand { get; private set; }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        public MaterialMovementViewModel()
        {
            _materialDatas = new List<ModuleMaterial>();
            _materialSubdatas1 = new ObservableCollection<ModuleMaterial>();
            _materialSubdatas2 = new ObservableCollection<ModuleMaterial>();
            _materialSubdatasBuffer1 = new List<ModuleMaterial>();
            _materialSubdatasBuffer2 = new List<ModuleMaterial>();
            UpdateLocationCommand = new DelegateCommand<object>(UpdateLocationAction);
            UpdateWaferCommand = new DelegateCommand<object>(UpdateWaferAction);
            RemoveCommand = new DelegateCommand<object>(RemoveAction);
            ModuleChangeCommand = new DelegateCommand<object>(ModuleChangeAction);
            SelectionChangeCommand = new DelegateCommand<object>(SelectionChangeAction);
            ResetWafersCommand = new DelegateCommand<object>(ResetWafersAction);

            ModuleLst.Clear();
            ModuleLst.Add(ModuleName.EfemRobot);
            ModuleLst.Add(ModuleName.LP1);
            ModuleLst.Add(ModuleName.LP2);
            ModuleLst.Add(ModuleName.LP3);
            ModuleLst.Add(ModuleName.Aligner1);
            ModuleLst.Add(ModuleName.PUF1);
            ModuleLst.Add(ModuleName.PUF2);
            ModuleLst.Add(ModuleName.Dummy1);
            ModuleLst.Add(ModuleName.Dummy2);
            ModuleLst.Add(ModuleName.Loader1);

            ModuleChangeAction("From");
            ModuleChangeAction("To");
            IsMoveEnable = false;
            IsRemoveEnable = false;
            IsWaferMoveEnable = false;
        }

        /// <summary>
        /// 加载数据
        /// </summary>
        /// <param name="systemName"></param>
        public void LoadData(string systemName)
        {
            _module = systemName;
            _rtDataKeys.Clear();
            _rtDataKeys.Add("System.LayoutCellItems");
            _rtDataKeys.Add("System.ModuleMaterials");
            _rtDataKeys.Add($"Transporter1.IsBusy");
            _rtDataKeys.Add($"Transporter2.IsBusy");
            _rtDataKeys.Add("System.IsAutoMode");
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    LocationLst = new ObservableCollection<string>(CommonFunction.GetValue<List<string>>(_rtDataValueDic, "System.LayoutCellItems"));
                    LocationLst.Add("Loader");
                    LocationLst.Add(ModuleName.Transporter1.ToString());
                    LocationLst.Add(ModuleName.Transporter2.ToString());
                }
            }

            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(200);
                _timer.Tick += Timer_Tick;
            }
            _timer.Start();
            
        }
        /// <summary>
        /// 时钟
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            IsMoveEnable = (FromLocation != null && ToLocation != null) ? true : false;
            IsRemoveEnable = string.IsNullOrEmpty(SelectedModuleName) ? false : true;
            IsWaferMoveEnable = (FromModule != ModuleName.System && ToModule != ModuleName.System && FromSlot != 0 && ToSlot != 0) ? true : false;
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    _isProcessTransBusy = CommonFunction.GetValue<bool>(_rtDataValueDic, $"Transporter1.IsBusy");
                    _isLoaderTransBusy = CommonFunction.GetValue<bool>(_rtDataValueDic, $"Transporter2.IsBusy");
                    _isAutoMode = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.IsAutoMode");
                    MaterialDatas = CommonFunction.GetValue<List<ModuleMaterial>>(_rtDataValueDic, "System.ModuleMaterials");
                    int i = 0;

                    _materialSubdatasBuffer1.Clear();
                    _materialSubdatasBuffer2.Clear();
                    for (i = 0; i < DATAGRIP_ROW_NUM; i++)
                    {
                        _materialSubdatasBuffer1.Add(MaterialDatas[i]);
                    }
                    for (; i < MaterialDatas.Count(); i++)
                    {
                        _materialSubdatasBuffer2.Add(MaterialDatas[i]);
                    }
         
                    //若数据变化则刷新数据
                    if ((_preMaterialDatas1.Count == 0) || (_preMaterialDatas1.Count != 0 && !CompareList(_preMaterialDatas1, _materialSubdatasBuffer1)))
                    {
                        MaterialSubdatas1 = new ObservableCollection<ModuleMaterial>(_materialSubdatasBuffer1);
                        _preMaterialDatas1 = new List<ModuleMaterial>(_materialSubdatasBuffer1);                                            
                    }                   
                    if ((_preMaterialDatas2.Count == 0) || (_preMaterialDatas2.Count != 0 && !CompareList(_preMaterialDatas2, _materialSubdatasBuffer2)))
                    {
                        MaterialSubdatas2 = new ObservableCollection<ModuleMaterial>(_materialSubdatasBuffer2);
                        _preMaterialDatas2 = new List<ModuleMaterial>(_materialSubdatasBuffer2);                       
                    }
                    //记忆SelectedItem   
                    if (SelectedMaterialData != null)
                    {
                        if (_gridSelection)
                        {
                            SelectedMaterialData1 = MaterialSubdatas1.ToList().Find(t => t.ModuleName == SelectedMaterialData.ModuleName);
                            SelectedMaterialData2 = null;                            
                        }
                        else
                        {
                            SelectedMaterialData2 = MaterialSubdatas2.ToList().Find(t => t.ModuleName == SelectedMaterialData.ModuleName);
                            SelectedMaterialData1 = null;                                                                                   
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 隐藏
        /// </summary>
        public void Hide()
        {
            if (_timer != null)
            {
                _timer.Stop();
            }
        }
        
        #region 命令方法
        private void UpdateLocationAction(object param)
        {
            WaferHolderInfo waferHolderInfo = WaferHolderDataClient.Instance.Service.GetWaferHolderDataByLocation(FromLocation);
            if (waferHolderInfo == null) return;
            if (!string.IsNullOrEmpty(FromLocation) && !string.IsNullOrEmpty(ToLocation))
            {
                if (!_isLoaderTransBusy && !_isProcessTransBusy && !_isAutoMode)
                {
                    InvokeClient.Instance.Service.DoOperation($"WaferHolder.TransferWaferHolder", $"{FromLocation}", $"{ToLocation}");
                }
                else if (_isAutoMode)
                {
                    MessageBox.Show("Auto mode can't do this operation", "Update", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                else
                {
                    MessageBox.Show("Loader or Process Transporter is in Busy state", "Update", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        /// <summary>
        /// 删除信息
        /// </summary>
        /// <param name="param"></param>
        private void RemoveAction(object param)
        {

            if (SelectedMaterialData == null)
            {
                MessageBox.Show("please select one data", "Delete", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if (string.IsNullOrEmpty(SelectedMaterialData.WaferHolderId) && SelectedMaterialData.SideAWaferStatus == 0 && SelectedMaterialData.SideBWaferStatus == 0)
            {
                MessageBox.Show("The data is Empt", "Delete", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if (MessageBox.Show("do you want to delete selected data", "Delete", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
            {
                if ((LocationLst.Contains(SelectedMaterialData.ModuleName) || SelectedMaterialData.ModuleName.Contains("Transporter")
                    || SelectedMaterialData.ModuleName.Contains("Loader")) && SelectedMaterialData.WaferHolderId != "")
                {
                    WaferHolderDataClient.Instance.Service.DeleteWaferHolderData(SelectedMaterialData.WaferHolderId);
                }
                else if (ModuleHelper.IsSRD(ModuleHelper.Converter(SelectedMaterialData.ModuleName)) || ModuleHelper.IsPUF(ModuleHelper.Converter(SelectedMaterialData.ModuleName)))
                {
                    if (SelectedMaterialData.SideAWaferId != "")
                        InvokeClient.Instance.Service.DoOperation("WaferManager.DeleteWafer", SelectedMaterialData.SideAWaferId);
                    if (SelectedMaterialData.SideBWaferId != "")
                        InvokeClient.Instance.Service.DoOperation("WaferManager.DeleteWafer", SelectedMaterialData.SideBWaferId);
                }               
                else
                {
                    return;
                }

            }
        }
        /// <summary>
        /// WaferMove 更新Slot列表
        /// </summary>
        /// <param name="obj"></param>
        private void ModuleChangeAction(object obj)
        {
            var value = obj.ToString();
            switch (value)
            {
                case "From":
                    FromSlotLst.Clear();
                    switch (FromModule)
                    {
                        case ModuleName.EfemRobot:
                            FromSlotLst.Add(1);
                            break;
                        case ModuleName.LP1:
                        case ModuleName.LP2:
                        case ModuleName.LP3:
                            for (int i = 1; i < 26; i++)
                            {
                                FromSlotLst.Add(i);
                            }
                            break;
                        case ModuleName.Aligner1:
                            FromSlotLst.Add(1);
                            break;
                        case ModuleName.PUF1:
                        case ModuleName.PUF2:
                            FromSlotLst.Add(1);
                            FromSlotLst.Add(2);
                            break;
                        case ModuleName.Dummy1:
                        case ModuleName.Dummy2:
                            for (int i = 1; i < 17; i++)
                            {
                                FromSlotLst.Add(i);
                            }
                            break;
                        case ModuleName.Loader1:
                            FromSlotLst.Add(1);
                            FromSlotLst.Add(2);
                            break;
                        default:
                            break;
                    }
                    break;
                case "To":
                    ToSlotLst.Clear();
                    switch (ToModule)
                    {
                        case ModuleName.EfemRobot:
                            ToSlotLst.Add(1);
                            break;
                        case ModuleName.LP1:
                        case ModuleName.LP2:
                        case ModuleName.LP3:
                            for (int i = 1; i < 26; i++)
                            {
                                ToSlotLst.Add(i);
                            }
                            break;
                        case ModuleName.Aligner1:
                            ToSlotLst.Add(1);
                            break;
                        case ModuleName.PUF1:
                        case ModuleName.PUF2:
                            ToSlotLst.Add(1);
                            ToSlotLst.Add(2);
                            break;
                        case ModuleName.Dummy1:
                        case ModuleName.Dummy2:
                            for (int i = 1; i < 17; i++)
                            {
                                ToSlotLst.Add(i);
                            }
                            break;
                        case ModuleName.Loader1:
                            ToSlotLst.Add(1);
                            ToSlotLst.Add(2);
                            break;
                        default:
                            break;
                    }
                    break;
                default:
                    break;
            }

        }
        /// <summary>
        /// 更新Wafer位置
        /// </summary>
        /// <param name="param"></param>
        private void UpdateWaferAction(object param)
        {
            if(ToModule == ModuleName.Loader1)
            {
                WaferHolderInfo waferHolderInfo = WaferHolderDataClient.Instance.Service.GetWaferHolderDataByLocation("Loader");
                if(waferHolderInfo == null)
                {
                    MessageBox.Show("Loader don't have wafer shuttle, can't move wafer!", "Delete", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
                InvokeClient.Instance.Service.DoOperation($"WaferManager.MoveWafer", FromModule, FromSlot - 1, ToModule, ToSlot - 1, waferHolderInfo.Id);
            }
            else if (FromModule == ModuleName.Loader1)
            {
                WaferHolderInfo waferHolderInfo = WaferHolderDataClient.Instance.Service.GetWaferHolderDataByLocation("Loader");
                if (waferHolderInfo == null)
                {
                    MessageBox.Show("Loader don't have wafer shuttle, can't move wafer!", "Delete", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }
                InvokeClient.Instance.Service.DoOperation($"WaferManager.MoveWafer", FromModule, FromSlot - 1, ToModule, ToSlot - 1, waferHolderInfo.Id);
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"WaferManager.MoveWafer", FromModule, FromSlot - 1, ToModule, ToSlot - 1);
            }      
            
        }
        /// <summary>
        /// Selection Change
        /// </summary>
        /// <param name="param"></param>
        private void SelectionChangeAction(object param)
        {
            string dg = param.ToString();
            if(dg == "DataGrid1")
            {               
                if (SelectedMaterialData1 != null)
                {
                    _gridSelection = true;
                    SelectedModuleName = SelectedMaterialData1.ModuleName;
                    SelectedMaterialData = SelectedMaterialData1;
                }
            }
            else
            {               
                if (SelectedMaterialData2 != null)
                {
                    _gridSelection = false;
                    SelectedModuleName = SelectedMaterialData2.ModuleName;
                    SelectedMaterialData = SelectedMaterialData2;
                }
            }
            
        }
        /// <summary>
        /// 重置Wafers
        /// </summary>
        /// <param name="param"></param>
        private void ResetWafersAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation("WaferHolder.ResetLayoutWafers");
        }
        private bool CompareList(List<ModuleMaterial> list1, List<ModuleMaterial> list2)
        {
            for(int i = 0; i < list1.Count; i++)
            {
                if (list1[i].WaferHolderId != list2[i].WaferHolderId || list1[i].SideAWaferId != list2[i].SideAWaferId || list1[i].SideAWaferType != list2[i].SideAWaferType || list1[i].SideAWaferStatus != list2[i].SideAWaferStatus
                || list1[i].SideBWaferId != list2[i].SideBWaferId || list1[i].SideBWaferType != list2[i].SideBWaferType || list1[i].SideBWaferStatus != list2[i].SideBWaferStatus || list1[i].ModuleName != list2[i].ModuleName)
                {
                    return false;
                }
            }
            return true;
        }
        
        #endregion

    }
}