using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase.IO;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Venus_Core;

namespace Venus_MainPages.ViewModels
{
    internal class OverViewModel : BindableBase
    {
        #region 私有字段
        private bool m_VN2Valve1IsOpen;
        private bool m_VN2Valve2IsOpen;
        private bool m_VN2Valve3IsOpen;
        private bool m_Gas1Valve1IsOpen;
        private bool m_Gas1Valve2IsOpen; 
        private bool m_Gas1Valve3IsOpen;
        private bool m_Gas2Valve1IsOpen;
        private bool m_Gas2Valve2IsOpen;
        private bool m_Gas2Valve3IsOpen;
        private bool m_Gas3Valve1IsOpen;
        private bool m_Gas3Valve2IsOpen;
        private bool m_Gas3Valve3IsOpen;
        private bool m_Gas4Valve1IsOpen;
        private bool m_Gas4Valve2IsOpen;
        private bool m_Gas4Valve3IsOpen;
        private bool m_Gas5ValveIsOpen;
        private bool m_Gas6ValveIsOpen;
        private bool m_Gas7ValveIsOpen;
        private bool m_Gas8ValveIsOpen;
        private bool m_GasFinalValveIsOpen;
        private bool m_PurgeValveIsOpen;
        private bool m_SoftPumpValveIsOpen;
        private bool m_FastPumpValveIsOpen;
       
        private AITPumpData m_MainPumpData=new AITPumpData ();

        private bool m_PumpIsOpen;
        private bool m_IsATM;
        private bool m_IsVAC;

        private string ModuleName;

        private List<string> m_RtConfigKeys;
        private Dictionary<string, object> m_RtConfigValues;

        private List<string> m_RtDataKeys;
        private Dictionary<string, object> m_RtDataValues;

        //private ObservableCollection<IOItem<float>> m_RtAiValues;
        //private ObservableCollection<AOItem> m_RtAOs;
        #endregion

        #region  属性      
        public Dictionary<string, object> RtConfigValues
        {
            get { return m_RtConfigValues; }
            set { SetProperty(ref m_RtConfigValues, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool GasFinalValveIsOpen
        {
            get { return m_GasFinalValveIsOpen; }
            set { SetProperty(ref m_GasFinalValveIsOpen, value); }
        }
        public bool VN2Valve1IsOpen
        {
            get { return m_VN2Valve1IsOpen; }
            set { SetProperty(ref m_VN2Valve1IsOpen, value); }
        }
        public bool VN2Valve2IsOpen
        {
            get { return m_VN2Valve2IsOpen; }
            set { SetProperty(ref m_VN2Valve2IsOpen, value); }
        }
        public bool VN2Valve3IsOpen
        {
            get { return m_VN2Valve3IsOpen; }
            set { SetProperty(ref m_VN2Valve3IsOpen, value); }
        }
        public bool Gas1Valve1IsOpen
        {
            get { return m_Gas1Valve1IsOpen; }
            set { SetProperty(ref m_Gas1Valve1IsOpen, value); }
        }
        public bool Gas1Valve2IsOpen
        {
            get { return m_Gas1Valve2IsOpen; }
            set { SetProperty(ref m_Gas1Valve2IsOpen, value); }
        }
        public bool Gas1Valve3IsOpen
        {
            get { return m_Gas1Valve3IsOpen; }
            set { SetProperty(ref m_Gas1Valve3IsOpen, value); }
        }
        public bool Gas2Valve1IsOpen
        {
            get { return m_Gas2Valve1IsOpen; }
            set { SetProperty(ref m_Gas2Valve1IsOpen, value); }
        }
        public bool Gas2Valve2IsOpen
        {
            get { return m_Gas2Valve2IsOpen; }
            set { SetProperty(ref m_Gas2Valve2IsOpen, value); }
        }
        public bool Gas2Valve3IsOpen
        {
            get { return m_Gas2Valve3IsOpen; }
            set { SetProperty(ref m_Gas2Valve3IsOpen, value); }
        }
        public bool Gas3Valve1IsOpen
        {
            get { return m_Gas3Valve1IsOpen; }
            set { SetProperty(ref m_Gas3Valve1IsOpen, value); }
        }
        public bool Gas3Valve2IsOpen
        {
            get { return m_Gas3Valve2IsOpen; }
            set { SetProperty(ref m_Gas3Valve2IsOpen, value); }
        }
        public bool Gas3Valve3IsOpen
        {
            get { return m_Gas3Valve3IsOpen; }
            set { SetProperty(ref m_Gas3Valve3IsOpen, value); }
        }
        public bool Gas4Valve1IsOpen
        {
            get { return m_Gas4Valve1IsOpen; }
            set { SetProperty(ref m_Gas4Valve1IsOpen, value); }
        }
        public bool Gas4Valve2IsOpen
        {
            get { return m_Gas4Valve2IsOpen; }
            set { SetProperty(ref m_Gas4Valve2IsOpen, value); }
        }
        public bool Gas4Valve3IsOpen
        {
            get { return m_Gas4Valve3IsOpen; }
            set { SetProperty(ref m_Gas4Valve3IsOpen, value); }
        }
        public bool Gas5ValveIsOpen
        {
            get { return m_Gas5ValveIsOpen; }
            set { SetProperty(ref m_Gas5ValveIsOpen, value); }
        }
        public bool Gas6ValveIsOpen
        {
            get { return m_Gas6ValveIsOpen; }
            set { SetProperty(ref m_Gas6ValveIsOpen, value); }
        }
        public bool Gas7ValveIsOpen
        {
            get { return m_Gas7ValveIsOpen; }
            set { SetProperty(ref m_Gas7ValveIsOpen, value); }
        }
        public bool Gas8ValveIsOpen
        {
            get { return m_Gas8ValveIsOpen; }
            set { SetProperty(ref m_Gas8ValveIsOpen, value); }
        }
        public bool PurgeValveIsOpen
        {
            get { return m_PurgeValveIsOpen; }
            set { SetProperty(ref m_PurgeValveIsOpen, value); }
        }
        public bool SoftPumpValveIsOpen
        {
            get { return m_SoftPumpValveIsOpen; }
            set { SetProperty(ref m_SoftPumpValveIsOpen, value); }
        }
        public bool FastPumpValveIsOpen
        {
            get { return m_FastPumpValveIsOpen; }
            set { SetProperty(ref m_FastPumpValveIsOpen, value); }
        }

        public AITPumpData MainPumpData
        {
            get { return m_MainPumpData; }
            set { SetProperty(ref m_MainPumpData, value); }
        }

        public bool PumpIsOpen
        {
            get { return m_PumpIsOpen; }
            set { SetProperty(ref m_PumpIsOpen, value); }
        }
        public bool IsATM
        {
            get { return m_IsATM; }
            set { SetProperty(ref m_IsATM, value); }
        }

        public bool IsVAC
        {
            get { return m_IsVAC; }
            set { SetProperty(ref m_IsVAC, value); }
        }
        #endregion

        #region 命令

        private DelegateCommand _PMInitCommnad;
        public DelegateCommand PMInitCommnad =>
            _PMInitCommnad ?? (_PMInitCommnad = new DelegateCommand(OnPMInit));

        private DelegateCommand _GasCommand;
        public DelegateCommand GasCommand =>
            _GasCommand ?? (_GasCommand = new DelegateCommand(OnGas));

        private DelegateCommand _RfCommand;
        public DelegateCommand RfCommand =>
            _RfCommand ?? (_RfCommand = new DelegateCommand(OnRf));

        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));


        #endregion

        #region 构造函数
        public OverViewModel()
        {
            m_RtConfigKeys=new List<string>();
            m_RtDataKeys = new List<string>();
            
            m_IsATM = true;

            ModuleName = "PMA";
            addConfigKeys();
            addDataKeys();

            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += timer_Tick;
            timer.Start();

            //GetRtAllData getRtAllData = new GetRtAllData();

        }
        void timer_Tick(object sender, EventArgs e)
        {
            RtConfigValues = QueryDataClient.Instance.Service.PollConfig(m_RtConfigKeys);
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

        }
        #endregion

        #region 命令方法

        private void OnPMInit()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Home");            
        }
        private void OnGas()
        {
            closeAllValve();
            Task.Run(() =>
            {
                //System.Threading.Thread.Sleep(100);
                VN2Valve1IsOpen = true;
                VN2Valve2IsOpen = true;
                VN2Valve3IsOpen = true;
                GasFinalValveIsOpen = true;
                Gas1Valve1IsOpen = true;
                Gas1Valve2IsOpen = true;
                Gas1Valve3IsOpen = true;
                Gas2Valve1IsOpen = true;
                Gas2Valve2IsOpen = true;
                Gas2Valve3IsOpen = true;
                Gas3Valve1IsOpen = true;
                Gas3Valve2IsOpen = true;
                Gas3Valve3IsOpen = true;
                Gas4Valve1IsOpen = true;
                Gas4Valve2IsOpen = true;
                Gas4Valve3IsOpen = true;
                Gas5ValveIsOpen = true;
                Gas6ValveIsOpen = true;
                Gas7ValveIsOpen = true;
                Gas8ValveIsOpen = true;
            });


        }

        private void OnRf()
        {
            closeAllValve();
            IsATM = !IsATM;
            
        }

        private void OnPurge()
        {
            closeAllValve();
            Task.Run(() => 
            { 
            PurgeValveIsOpen = true;
            });
        }

        private void OnVent()
        {
            closeAllValve();

            Task.Run(() =>
            {
                //System.Threading.Thread.Sleep(100);
                VN2Valve2IsOpen = true;
                VN2Valve3IsOpen = true;
                GasFinalValveIsOpen = true;
            });
           

        }

        private void OnPump()
        {
            if (PumpIsOpen == true)
            {
                FastPumpValveIsOpen = true;
            }          
        }

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

        #region 私有方法

        private void addConfigKeys()
        {
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas1.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas2.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas3.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas4.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas5.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas6.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas7.GasName");
            m_RtConfigKeys.Add($"{ModuleName}.MfcGas8.GasName");
        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"{ModuleName}.FsmState");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas1.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas2.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas3.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas4.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas5.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas6.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas7.FeedBack");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas8.FeedBack");

            m_RtDataKeys.Add($"{ModuleName}.ForelinePressure");
            m_RtDataKeys.Add($"{ModuleName}.ProcessPressure");
            m_RtDataKeys.Add($"{ModuleName}.ChamberPressure");

            m_RtDataKeys.Add($"{ModuleName}.IsATM");
            m_RtDataKeys.Add($"{ModuleName}.IsVAC");

            m_RtDataKeys.Add($"{ModuleName}.LiftPinIsUp");
            m_RtDataKeys.Add($"{ModuleName}.LiftPinIsDown");




        }
        private void closeAllValve()
        {
            if (VN2Valve1IsOpen == true) VN2Valve1IsOpen = false;
            if (VN2Valve2IsOpen == true) VN2Valve2IsOpen = false;
            if (VN2Valve3IsOpen == true) VN2Valve3IsOpen = false;
            if (GasFinalValveIsOpen == true) GasFinalValveIsOpen = false;
            if (Gas1Valve1IsOpen == true) Gas1Valve1IsOpen = false;
            if (Gas1Valve2IsOpen == true) Gas1Valve2IsOpen = false;
            if (Gas1Valve3IsOpen == true) Gas1Valve3IsOpen = false;
            if (Gas2Valve1IsOpen == true) Gas2Valve1IsOpen = false;
            if (Gas2Valve2IsOpen == true) Gas2Valve2IsOpen = false;
            if (Gas2Valve3IsOpen == true) Gas2Valve3IsOpen = false;
            if (Gas3Valve1IsOpen == true) Gas3Valve1IsOpen = false;
            if (Gas3Valve2IsOpen == true) Gas3Valve2IsOpen = false;
            if (Gas3Valve3IsOpen == true) Gas3Valve3IsOpen = false;
            if (Gas4Valve1IsOpen == true) Gas4Valve1IsOpen = false;
            if (Gas4Valve2IsOpen == true) Gas4Valve2IsOpen = false;
            if (Gas4Valve3IsOpen == true) Gas4Valve3IsOpen = false;
            if (Gas5ValveIsOpen == true) Gas5ValveIsOpen = false;
            if (Gas6ValveIsOpen == true) Gas6ValveIsOpen = false;
            if (Gas7ValveIsOpen == true) Gas7ValveIsOpen = false;
            if (Gas8ValveIsOpen == true) Gas8ValveIsOpen = false;
        }
        #endregion
    }
}