//using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;
using WPF.Themes.UserControls;

namespace Venus_MainPages.ViewModels
{
    public class PlatformViewModel : BindableBase
    {
        #region 私有字段
        private bool m_LoadLockDoorIsOpen;
        private bool m_LoadLockPumpValveIsOpen;
        private bool m_LoadLockVentValveIsOpen;
        private bool m_IsATM;
        private string ModuleName="PMA";
        private List<string> m_RtDataKeys=new List<string> ();
        private Dictionary<string, object> m_RtDataValues=new Dictionary<string, object> ();
        private bool m_PumpIsOpen;
        private int m_PurgeCounter;
        private Visibility m_PMAWaferIsVisibility;
        private Visibility m_LLAWaferIsVisibility;
        private PMState m_PMCurrentState;
        private WaferInfo m_LLAWafer;
        private WaferInfo m_PMAWafer;
        private bool m_WaferInPosSensor;
        #endregion

        #region  属性
        public bool WaferInPosSensor
        {
            get { return m_WaferInPosSensor; }
            set 
            {
                if (m_WaferInPosSensor != value)
                {
                    if (value == true && LLAWaferIsVisibility==Visibility.Collapsed && PMCurrentState!=PMState.LLPicking && PMCurrentState != PMState.LLPlacing)
                    {
                        InvokeClient.Instance.Service.DoOperation("CreateWafer", "LLA", 0);
                    }
                    else if (value == false && LLAWaferIsVisibility == Visibility.Visible && PMCurrentState != PMState.LLPicking && PMCurrentState != PMState.LLPlacing)
                    {
                        InvokeClient.Instance.Service.DoOperation("DeleteWafer", "LLA", 0);
                    }
                }
                SetProperty(ref m_WaferInPosSensor, value);
            }
        }

        public WaferInfo LLAWafer
        {
            get { return m_LLAWafer; }
            set { SetProperty(ref m_LLAWafer, value); }
        }
        public WaferInfo PMAWafer
        {
            get { return m_PMAWafer; }
            set { SetProperty(ref m_PMAWafer, value); }
        }
        public bool LoadLockDoorIsOpen
        {
            get { return m_LoadLockDoorIsOpen; }
            set {  SetProperty(ref m_LoadLockDoorIsOpen, value); }
        }
        public bool LoadLockPumpValveIsOpen
        {
            get { return m_LoadLockPumpValveIsOpen; }
            set { SetProperty(ref m_LoadLockPumpValveIsOpen, value); }
        }
        public bool LoadLockVentValveIsOpen
        {
            get { return m_LoadLockVentValveIsOpen; }
            set { SetProperty(ref m_LoadLockVentValveIsOpen, value); }
        }
        public bool IsATM
        {
            get { return m_IsATM; }
            set { SetProperty(ref m_IsATM, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool PumpIsOpen
        {
            get { return m_PumpIsOpen; }
            set { SetProperty(ref m_PumpIsOpen, value); }
        }

        public int PurgeCounter
        {
            get { return m_PurgeCounter; }
            set { SetProperty(ref m_PurgeCounter, value); }
        }
        public Visibility PMAWaferIsVisibility
        {
            get { return m_PMAWaferIsVisibility; }
            set { SetProperty(ref m_PMAWaferIsVisibility, value); }
        }

        public Visibility LLAWaferIsVisibility
        {
            get { return m_LLAWaferIsVisibility; }
            set { SetProperty(ref m_LLAWaferIsVisibility, value); }
        }
        public PMState PMCurrentState
        {
            get { return m_PMCurrentState; }
            set { SetProperty(ref m_PMCurrentState, value); }
        }
        #endregion


        #region 命令
        private DelegateCommand _PurgeCommand;
        public DelegateCommand PurgeCommand =>
            _PurgeCommand ?? (_PurgeCommand = new DelegateCommand(OnPurge));

        private DelegateCommand _VentCommand;
        public DelegateCommand VentCommand =>
            _VentCommand ?? (_VentCommand = new DelegateCommand(OnVent));

        private DelegateCommand _PumpCommand;
        public DelegateCommand PumpCommand =>
            _PumpCommand ?? (_PumpCommand = new DelegateCommand(OnPump));

        private DelegateCommand _OpenPumpCommand;
        public DelegateCommand OpenPumpCommand =>
            _OpenPumpCommand ?? (_OpenPumpCommand = new DelegateCommand(OnOpenPump));

        private DelegateCommand _ClosePumpCommand;
        public DelegateCommand ClosePumpCommand =>
            _ClosePumpCommand ?? (_ClosePumpCommand = new DelegateCommand(OnClosePump));

        private DelegateCommand _OpenDoorCommand;
        public DelegateCommand OpenDoorCommand =>
            _OpenDoorCommand ?? (_OpenDoorCommand = new DelegateCommand(OnOpenDoor));

        private DelegateCommand _CloseDoorCommand;
        public DelegateCommand CloseDoorCommand =>
            _CloseDoorCommand ?? (_CloseDoorCommand = new DelegateCommand(OnCloseDoor));

        private DelegateCommand _NewWaferCommand;
        public DelegateCommand NewWaferCommand =>
            _NewWaferCommand ?? (_NewWaferCommand = new DelegateCommand(OnNewWafer));

        private DelegateCommand _DeleteWaferCommand;
        public DelegateCommand DeleteWaferCommand =>
            _DeleteWaferCommand ?? (_DeleteWaferCommand = new DelegateCommand(OnDeleteWafer));

        private DelegateCommand _PlaceWaferCommand;
        public DelegateCommand PlaceWaferCommand =>
            _PlaceWaferCommand ?? (_PlaceWaferCommand = new DelegateCommand(OnPlaceWafer));

        private DelegateCommand _MoveWaferCommand;
        public DelegateCommand MoveWaferCommand =>
            _MoveWaferCommand ?? (_MoveWaferCommand = new DelegateCommand(OnMoveWafer));

        private DelegateCommand<object> _ControlValveCommand;
        public DelegateCommand<object> ControlValveCommand =>
            _ControlValveCommand ?? (_ControlValveCommand = new DelegateCommand<object>(OnControlValve));

        #endregion

        #region 构造函数
        public PlatformViewModel()
        {
            ModuleManager.Initialize();

            //m_PMAWaferIsVisibility = Visibility.Collapsed;
            //m_IsATM = true;
            //var test = RTData.GetRTData().RtDataValues;
            addDataKeys();
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.1);
            timer.Tick += timer_Tick;
            timer.Start();

            
        }

        #endregion

        #region 命令方法   

        private void OnPump()
        {
            if (PMCurrentState == PMState.PumpingLoadLock)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            { 
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.PumpLoadLock");
            }
        }
        private void OnPurge()
        {
            if (PMCurrentState == PMState.PurgingLoadLock)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.PurgeLoadLock");

            }
        }

        private void OnVent()
        {
            if (PMCurrentState == PMState.VentingLoadLock)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.VentLoadLock");

            }
        }
        private void OnOpenPump()
        {
            if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "LaunchingPump")
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StartPump");
        }
        private void OnClosePump()
        {
            //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");

        }
        private void OnOpenDoor()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSlitDoor",true);
            
        }
        private void OnCloseDoor()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSlitDoor",false);
        }
        private void OnNewWafer()
        {
            //if (WaferIsVisibility != Visibility.Visible)
            //{
            //    WaferIsVisibility = Visibility.Visible;
            //}
            //else
            //{
            //    WPFMessageBox.ShowInformation("晶圆已创建");
            //}
            InvokeClient.Instance.Service.DoOperation("CreateWafer", "PMA", 0);
        }

        private void OnDeleteWafer()
        {
            //WaferIsVisibility = Visibility.Collapsed;
            InvokeClient.Instance.Service.DoOperation("DeleteWafer", "PMA", 0);
        }

        private void OnPlaceWafer()
        {
            if (PMCurrentState == PMState.LLPlacing)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.LLPlace}");
            }
        }
        private void OnMoveWafer()
        {
            if (PMCurrentState == PMState.LLPicking)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.LLPick}");

            }
        }
        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", Convert.ToInt32(commonValveControl.Tag.ToString()), !commonValveControl.Status);
            }
        }
        #endregion

        #region 私有方法
        void timer_Tick(object sender, EventArgs e)
        {

            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            LoadLockPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveLoadlockPumping.IsOpen");

            LoadLockVentValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveLoadlockVent.IsOpen"); 
            PumpIsOpen = (bool)RtDataValues[$"{ModuleName}.PumpIsRunning"];
            PurgeCounter=(int)RtDataValues[$"{ModuleName}.LoadLockPurge.PurgeCounter"];

            LLAWafer = ModuleManager.ModuleInfos["LLA"].WaferManager.Wafers[0];
            PMAWafer = ModuleManager.ModuleInfos["PMA"].WaferManager.Wafers[0];
            

            PMAWaferIsVisibility = (bool)RtDataValues[$"PMA.HasWafer"] ==true ? Visibility.Visible : Visibility.Collapsed;
            LLAWaferIsVisibility = (bool)RtDataValues[$"LLA.HasWafer"] == true ? Visibility.Visible : Visibility.Collapsed;

            PMCurrentState= (PMState)Enum.Parse(typeof(PMState), RtDataValues[$"{ModuleName}.FsmState"].ToString());

            WaferInPosSensor = (bool)RtDataValues[$"{ModuleName}.SensorSmallWaferInPos.Value"];
        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"{ModuleName}.FsmState");
            m_RtDataKeys.Add($"{ModuleName}.ValveLoadlockPumping.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveLoadlockVent.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.PumpIsRunning");
            m_RtDataKeys.Add($"{ModuleName}.LoadLockPurge.PurgeCounter");
            m_RtDataKeys.Add($"{ModuleName}.IsSlitDoorClosed");
            m_RtDataKeys.Add($"{ModuleName}.LoadlockPressure");
            m_RtDataKeys.Add($"{ModuleName}.ForelinePressure");
            m_RtDataKeys.Add($"{ModuleName}.IsATMLoadlock");
            m_RtDataKeys.Add($"{ModuleName}.IsVACLoadlock");
            m_RtDataKeys.Add($"PMA.HasWafer");
            m_RtDataKeys.Add($"PMA.ModuleWaferList");
            m_RtDataKeys.Add($"LLA.HasWafer");
            m_RtDataKeys.Add($"LLA.ModuleWaferList");
            m_RtDataKeys.Add($"{ModuleName}.SensorSmallWaferInPos.Value");
        }

        #endregion
    }
}