using Aitex.Core.Common.DeviceData;
using Aitex.Core.Util;
using Caliburn.Micro;
using Caliburn.Micro.Core;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using MECF.Framework.UI.Core.Control;
using OpenSEMI.ClientBase;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using FurnaceUI.Models;
using FurnaceUI.Views.Editors;

namespace FurnaceUI.Views.Operations
{
    public class GasDetailViewModel : FurnaceUIViewModelBase
    {
        #region MFC
        [Subscription("CHM.MFC1.DeviceData")]
        public AITMfcData MFC1Data { get; set; }
        [Subscription("CHM.MFC2.DeviceData")]
        public AITMfcData MFC2Data { get; set; }
        [Subscription("CHM.MFC3.DeviceData")]
        public AITMfcData MFC3Data { get; set; }

        [Subscription("CHM.MFC4.DeviceData")]
        public AITMfcData MFC4Data { get; set; }

        [Subscription("CHM.MFC5.DeviceData")]
        public AITMfcData MFC5Data { get; set; }

        [Subscription("CHM.MFC6.DeviceData")]
        public AITMfcData MFC6Data { get; set; }

        [Subscription("CHM.MFC7.DeviceData")]
        public AITMfcData MFC7Data { get; set; }

        [Subscription("CHM.MFC8.DeviceData")]
        public AITMfcData MFC8Data { get; set; }

        [Subscription("CHM.MFC9.DeviceData")]
        public AITMfcData MFC9Data { get; set; }

        [Subscription("CHM.MFC10.DeviceData")]
        public AITMfcData MFC10Data { get; set; }

        [Subscription("CHM.MFC11.DeviceData")]
        public AITMfcData MFC11Data { get; set; }

        [Subscription("CHM.MFC12.DeviceData")]
        public AITMfcData MFC12Data { get; set; }

        [Subscription("CHM.MFC51.DeviceData")]
        public AITMfcData MFC51Data { get; set; }
        #endregion

        #region MFM
        [Subscription("CHM.MFM57.DeviceData")]
        public AITWaterFlowMeterData MFM57FlowData { get; set; }
        #endregion

        #region Valve
        [Subscription("CHM.ValveAV1.DeviceData")]
        public AITValveData ValveAV1Data { get; set; }
        [Subscription("CHM.ValveAV2.DeviceData")]
        public AITValveData ValveAV2Data { get; set; }
        [Subscription("CHM.ValveAV3.DeviceData")]
        public AITValveData ValveAV3Data { get; set; }
        [Subscription("CHM.ValveAV4.DeviceData")]
        public AITValveData ValveAV4Data { get; set; }
        [Subscription("CHM.ValveAV5.DeviceData")]
        public AITValveData ValveAV5Data { get; set; }
        [Subscription("CHM.ValveAV6.DeviceData")]
        public AITValveData ValveAV6Data { get; set; }
        [Subscription("CHM.ValveAV7.DeviceData")]
        public AITValveData ValveAV7Data { get; set; }
        [Subscription("CHM.ValveAV8.DeviceData")]
        public AITValveData ValveAV8Data { get; set; }
        [Subscription("CHM.ValveAV9.DeviceData")]
        public AITValveData ValveAV9Data { get; set; }
        [Subscription("CHM.ValveAV10.DeviceData")]
        public AITValveData ValveAV10Data { get; set; }
        [Subscription("CHM.ValveAV11.DeviceData")]
        public AITValveData ValveAV11Data { get; set; }
        [Subscription("CHM.ValveAV12.DeviceData")]
        public AITValveData ValveAV12Data { get; set; }
        [Subscription("CHM.ValveAV13.DeviceData")]
        public AITValveData ValveAV13Data { get; set; }
        [Subscription("CHM.ValveAV14.DeviceData")]
        public AITValveData ValveAV14Data { get; set; }
        [Subscription("CHM.ValveAV15.DeviceData")]
        public AITValveData ValveAV15Data { get; set; }
        [Subscription("CHM.ValveAV16.DeviceData")]
        public AITValveData ValveAV16Data { get; set; }
        [Subscription("CHM.ValveAV17.DeviceData")]
        public AITValveData ValveAV17Data { get; set; }
        [Subscription("CHM.ValveAV18.DeviceData")]
        public AITValveData ValveAV18Data { get; set; }
        [Subscription("CHM.ValveAV19.DeviceData")]
        public AITValveData ValveAV19Data { get; set; }
        [Subscription("CHM.ValveAV20.DeviceData")]
        public AITValveData ValveAV20Data { get; set; }
        [Subscription("CHM.ValveAV21.DeviceData")]
        public AITValveData ValveAV21Data { get; set; }
        [Subscription("CHM.ValveAV22.DeviceData")]
        public AITValveData ValveAV22Data { get; set; }
        [Subscription("CHM.ValveAV23.DeviceData")]
        public AITValveData ValveAV23Data { get; set; }
        [Subscription("CHM.ValveAV24.DeviceData")]
        public AITValveData ValveAV24Data { get; set; }
        [Subscription("CHM.ValveAV25.DeviceData")]
        public AITValveData ValveAV25Data { get; set; }
        [Subscription("CHM.ValveAV26.DeviceData")]
        public AITValveData ValveAV26Data { get; set; }
        [Subscription("CHM.ValveAV27.DeviceData")]
        public AITValveData ValveAV27Data { get; set; }
        [Subscription("CHM.ValveAV28.DeviceData")]
        public AITValveData ValveAV28Data { get; set; }
        [Subscription("CHM.ValveAV29.DeviceData")]
        public AITValveData ValveAV29Data { get; set; }
        [Subscription("CHM.ValveAV30.DeviceData")]
        public AITValveData ValveAV30Data { get; set; }
        [Subscription("CHM.ValveAV31.DeviceData")]
        public AITValveData ValveAV31Data { get; set; }
        [Subscription("CHM.ValveAV32.DeviceData")]
        public AITValveData ValveAV32Data { get; set; }
        [Subscription("CHM.ValveAV33.DeviceData")]
        public AITValveData ValveAV33Data { get; set; }
        [Subscription("CHM.ValveAV34.DeviceData")]
        public AITValveData ValveAV34Data { get; set; }
        [Subscription("CHM.ValveAV35.DeviceData")]
        public AITValveData ValveAV35Data { get; set; }
        [Subscription("CHM.ValveAV36.DeviceData")]
        public AITValveData ValveAV36Data { get; set; }
        [Subscription("CHM.ValveAV37.DeviceData")]
        public AITValveData ValveAV37Data { get; set; }

        [Subscription("CHM.ValveAV38.DeviceData")]
        public AITValveData ValveAV38Data { get; set; }
        [Subscription("CHM.ValveAV39.DeviceData")]
        public AITValveData ValveAV39Data { get; set; }
        [Subscription("CHM.ValveAV52.DeviceData")]
        public AITValveData ValveAV52Data { get; set; }
        [Subscription("CHM.ValveAV54.DeviceData")]
        public AITValveData ValveAV54Data { get; set; }
        [Subscription("CHM.ValveAV56.DeviceData")]
        public AITValveData ValveAV56Data { get; set; }

        [Subscription("CHM.ValveAV57.DeviceData")]
        public AITValveData ValveAV57Data { get; set; }
        [Subscription("CHM.ValveAV58.DeviceData")]
        public AITValveData ValveAV58Data { get; set; }
        [Subscription("CHM.ValveAV59.DeviceData")]
        public AITValveData ValveAV59Data { get; set; }
        [Subscription("CHM.ValveAV60.DeviceData")]
        public AITValveData ValveAV60Data { get; set; }
        [Subscription("CHM.ValveAV68.DeviceData")]
        public AITValveData ValveAV68Data { get; set; }
        [Subscription("CHM.ValveAV71.DeviceData")]
        public AITValveData ValveAV71Data { get; set; }
        [Subscription("CHM.ValveAV72.DeviceData")]
        public AITValveData ValveAV72Data { get; set; }
        [Subscription("CHM.ValveAV73.DeviceData")]
        public AITValveData ValveAV73Data { get; set; }
        [Subscription("CHM.ValveAV74.DeviceData")]
        public AITValveData ValveAV74Data { get; set; }
        [Subscription("CHM.ValveAV75.DeviceData")]
        public AITValveData ValveAV75Data { get; set; }
        [Subscription("CHM.ValveAV77.DeviceData")]
        public AITValveData ValveAV77Data { get; set; }
        [Subscription("CHM.ValveAV81.DeviceData")]
        public AITValveData ValveAV81Data { get; set; }
        [Subscription("CHM.ValveAV82.DeviceData")]
        public AITValveData ValveAV82Data { get; set; }
        [Subscription("CHM.ValveAV83.DeviceData")]
        public AITValveData ValveAV83Data { get; set; }
        [Subscription("CHM.ValveAV91.DeviceData")]
        public AITValveData ValveAV91Data { get; set; }
        #endregion

        #region APC
        [Subscription("PM1.APC.DeviceData")]
        public AITThrottleValveData APCData { get; set; }
        #endregion

        #region Analog
        [Subscription("PM1.HTCurrent1.DeviceData")]
        public AITWaterFlowMeterData HTCurrent1 { get; set; }
        [Subscription("PM1.HTCurrent2.DeviceData")]
        public AITWaterFlowMeterData HTCurrent2 { get; set; }
        [Subscription("PM1.HTCurrent3.DeviceData")]
        public AITWaterFlowMeterData HTCurrent3 { get; set; }
        [Subscription("PM1.HTCurrent4.DeviceData")]
        public AITWaterFlowMeterData HTCurrent4 { get; set; }
        [Subscription("PM1.HTCurrent5.DeviceData")]
        public AITWaterFlowMeterData HTCurrent5 { get; set; }
        [Subscription("PM1.HTVoltage1.DeviceData")]
        public AITWaterFlowMeterData HTVoltage1 { get; set; }
        [Subscription("PM1.HTVoltage2.DeviceData")]
        public AITWaterFlowMeterData HTVoltage2 { get; set; }
        [Subscription("PM1.HTVoltage3.DeviceData")]
        public AITWaterFlowMeterData HTVoltage3 { get; set; }
        [Subscription("PM1.HTVoltage4.DeviceData")]
        public AITWaterFlowMeterData HTVoltage4 { get; set; }
        [Subscription("PM1.HTVoltage5.DeviceData")]
        public AITWaterFlowMeterData HTVoltage5 { get; set; }
        [Subscription("PM1.HeaterWaterFlow.DeviceData")]
        public AITWaterFlowMeterData HeaterWaterFlow { get; set; }
        [Subscription("PM1.MFWaterFlow.DeviceData")]
        public AITWaterFlowMeterData MFWaterFlow { get; set; }
        [Subscription("PM1.CAPWaterFlow.DeviceData")]
        public AITWaterFlowMeterData CAPWaterFlow { get; set; }
        [Subscription("PM1.A_SWaterFlow.DeviceData")]
        public AITWaterFlowMeterData A_SWaterFlow { get; set; }
        [Subscription("PM1.HeaterEXH.DeviceData")]
        public AITWaterFlowMeterData HeaterEXH { get; set; }
        [Subscription("PM1.SCVEXH.DeviceData")]
        public AITWaterFlowMeterData SCVEXH { get; set; }
        [Subscription("PM1.G_UEXH.DeviceData")]
        public AITWaterFlowMeterData G_UEXH { get; set; }
        [Subscription("PM1.PT1Value.DeviceData")]
        public AITWaterFlowMeterData PT1Value { get; set; }
        [Subscription("PM1.PT2Value.DeviceData")]
        public AITWaterFlowMeterData PT2Value { get; set; }
        [Subscription("PM1.PT3Value.DeviceData")]
        public AITWaterFlowMeterData PT3Value { get; set; }
        [Subscription("PM1.PT4Value.DeviceData")]
        public AITWaterFlowMeterData PT4Value { get; set; }
        [Subscription("PM1.PT5Value.DeviceData")]
        public AITWaterFlowMeterData PT5Value { get; set; }
        [Subscription("PM1.PT6Value.DeviceData")]
        public AITWaterFlowMeterData PT6Value { get; set; }
        [Subscription("PM1.P_SW1Value.DeviceData")]
        public AITWaterFlowMeterData P_SW1Value { get; set; }
        [Subscription("PM1.P_SW2Value.DeviceData")]
        public AITWaterFlowMeterData P_SW2Value { get; set; }
        [Subscription("PM1.VG2Pressure.DeviceData")]
        public AITWaterFlowMeterData VG2Pressure { get; set; }
        #endregion

        #region PM
        [Subscription("PM1.Status")]
        public string PM1Status { get; set; }

        [Subscription("PM1.RecipeHold")]
        public bool PM1RecipeHold { get; set; }

        public bool IsMannualButtonEnabled
        {
            get
            {
                return PM1Status != "Process" || (PM1Status == "Process" && PM1RecipeHold);
            }
        }
        #endregion

        private Visibility _gridMFCVisibility = Visibility.Hidden;

        public Visibility GridMFCVisibility
        {
            get => _gridMFCVisibility;
            set
            {
                _gridMFCVisibility = value;
                NotifyOfPropertyChange("GridMFCVisibility");
            }
        }

        private Visibility _gridMFMVisibility = Visibility.Hidden;

        public Visibility GridMFMVisibility
        {
            get => _gridMFMVisibility;
            set
            {
                _gridMFMVisibility = value;
                NotifyOfPropertyChange("GridMFMVisibility");
            }
        }

        private Visibility _gridValveVisibility = Visibility.Hidden;

        public Visibility GridValveVisibility
        {
            get => _gridValveVisibility;
            set
            {
                _gridValveVisibility = value;
                NotifyOfPropertyChange("GridValveVisibility");
            }
        }

        private Visibility _gridAPCVisibility = Visibility.Hidden;

        public Visibility GridAPCVisibility
        {
            get => _gridAPCVisibility;
            set
            {
                _gridAPCVisibility = value;
                NotifyOfPropertyChange("GridAPCVisibility");
            }
        }

        private Visibility _gridAnalogVisibility = Visibility.Hidden;

        public Visibility GridAnalogVisibility
        {
            get => _gridAnalogVisibility;
            set
            {
                _gridAnalogVisibility = value;
                NotifyOfPropertyChange("GridAnalogVisibility");
            }
        }

        private ObservableCollection<MFCDetailValue> _mfcDetailDatas = new ObservableCollection<MFCDetailValue>();

        public ObservableCollection<MFCDetailValue> MFCDetailDatas
        {
            get => _mfcDetailDatas;
            set
            {
                _mfcDetailDatas = value;
                NotifyOfPropertyChange("MFCDetailDatas");
            }
        }

        private ObservableCollection<MFMDetailValue> _mfmDetailDatas = new ObservableCollection<MFMDetailValue>();

        public ObservableCollection<MFMDetailValue> MFMDetailDatas
        {
            get => _mfmDetailDatas;
            set
            {
                _mfmDetailDatas = value;
                NotifyOfPropertyChange("MFMDetailDataLists");
            }
        }

        private ObservableCollection<ValveDetailValue> _valveDetailDatas = new ObservableCollection<ValveDetailValue>();
        public ObservableCollection<ValveDetailValue> ValveDetailDatas
        {
            get => _valveDetailDatas;
            set
            {
                _valveDetailDatas = value;
                NotifyOfPropertyChange("ValveDetailDatas");
            }
        }

        private ObservableCollection<MFMDetailValue> _apcDetailDatas = new ObservableCollection<MFMDetailValue>();

        public ObservableCollection<MFMDetailValue> APCDetailDatas
        {
            get => _apcDetailDatas;
            set
            {
                _apcDetailDatas = value;
                NotifyOfPropertyChange("APCDetailDatas");
            }
        }

        private ObservableCollection<AnalogDetailValue> _analogDetailDatas = new ObservableCollection<AnalogDetailValue>();
        public ObservableCollection<AnalogDetailValue> AnalogDetailDatas
        {
            get => _analogDetailDatas;
            set
            {
                AnalogDetailDatas = value;
                NotifyOfPropertyChange("AnalogDetailDatas");
            }
        }

        private bool _isEnableMannual;
        public bool IsEnableMannual
        {
            get => _isEnableMannual;
            set
            {
                _isEnableMannual = value;
                NotifyOfPropertyChange(nameof(IsEnableMannual));
            }
        }

        private int _mannualSelectCount;

        protected override void OnViewLoaded(object view)
        {

            base.OnViewLoaded(view);
            GridMFCVisibility = Visibility.Visible;
        }

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

            if (!IsEnableMannual)
                UpdateFlowValue();
        }

        private void UpdateFlowValue()
        {
            List<AITMfcData> mfcData = new List<AITMfcData>()
            {
                MFC1Data,
                MFC2Data,
                MFC3Data,
                MFC4Data,
                MFC5Data,
                MFC6Data,
                MFC7Data,
                MFC8Data,
                MFC9Data,
                MFC10Data,
                MFC11Data,
                MFC12Data,
                MFC51Data,
            };

            List<AITMfcData> tempMFC = new List<AITMfcData>();
            for (int i = 0; i < mfcData.Count; i++)
            {
                var IsMFCInstalled = (bool)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{mfcData[i].DeviceName}.IsMFCInstalled");
                if (IsMFCInstalled)
                {
                    tempMFC.Add(mfcData[i]);
                }
            }

            List<AITWaterFlowMeterData> mfmData = new List<AITWaterFlowMeterData>()
            {
                MFM57FlowData,
            };

            List<AITWaterFlowMeterData> tempMFM = new List<AITWaterFlowMeterData>();
            for (int i = 0; i < mfmData.Count; i++)
            {
                var IsMFMInstalled = (bool)QueryDataClient.Instance.Service.GetConfig($"PM1.MFM.{mfmData[i].DeviceName}.IsMFMInstalled");
                if (IsMFMInstalled)
                {
                    tempMFM.Add(mfmData[i]);
                }
            }

            List<AITThrottleValveData> apcData = new List<AITThrottleValveData>()
            {
                APCData,
            };

            List<AITValveData> valveData = new List<AITValveData>()
            {
                ValveAV1Data,
                ValveAV2Data,
                ValveAV3Data,
                ValveAV4Data,
                ValveAV5Data,
                ValveAV6Data,
                ValveAV7Data,
                ValveAV8Data,
                ValveAV9Data,
                ValveAV10Data,
                ValveAV11Data,
                ValveAV12Data,
                ValveAV13Data,
                ValveAV14Data,
                ValveAV15Data,
                ValveAV16Data,
                ValveAV17Data,
                ValveAV18Data,
                ValveAV19Data,
                ValveAV20Data,
                ValveAV21Data,
                ValveAV22Data,
                ValveAV23Data,
                ValveAV24Data,
                ValveAV25Data,
                ValveAV26Data,
                ValveAV27Data,
                ValveAV28Data,
                ValveAV29Data,
                ValveAV30Data,
                ValveAV31Data,
                ValveAV32Data,
                ValveAV33Data,
                ValveAV34Data,
                ValveAV35Data,
                ValveAV36Data,
                ValveAV37Data,
                ValveAV38Data,
                ValveAV39Data,
                ValveAV52Data,
                ValveAV54Data,
                ValveAV56Data,
                ValveAV57Data,
                ValveAV58Data,
                ValveAV59Data,
                ValveAV60Data,
                ValveAV68Data,
                ValveAV71Data,
                ValveAV72Data,
                ValveAV73Data,
                ValveAV74Data,
                ValveAV75Data,
                ValveAV77Data,
                ValveAV81Data,
                ValveAV82Data,
                ValveAV83Data,
                ValveAV91Data,
            };

            //List<AITWaterFlowMeterData> analogData = new List<AITWaterFlowMeterData>()
            //{
            //    HTCurrent1,
            //    HTCurrent2,
            //    HTCurrent3,
            //    HTCurrent4,
            //    HTCurrent5,
            //    HTVoltage1,
            //    HTVoltage2,
            //    HTVoltage3,
            //    HTVoltage4,
            //    HTVoltage5,
            //    HeaterWaterFlow,
            //    MFWaterFlow,
            //    CAPWaterFlow,
            //    A_SWaterFlow,
            //    HeaterEXH,
            //    SCVEXH,
            //    G_UEXH,
            //    PT1Value,
            //    PT2Value,
            //    PT3Value,
            //    PT4Value,
            //    PT5Value,
            //    PT6Value,
            //    P_SW1Value,
            //    P_SW2Value,
            //};

            if (MFCDetailDatas.Count == 0)
            {
                for (int i = 0; i < tempMFC.Count; i++)
                {
                    var Unit = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{tempMFC[i].DeviceName}.FlowUnit");
                    var setpoint = mfcData[i].SetPoint.ToString("F1");
                    MFCDetailDatas.Add(new MFCDetailValue()
                    {
                        Name = tempMFC[i].DeviceName,
                        DisplayName = tempMFC[i].DisplayName,
                        Unit = Unit,
                        Setpoint = setpoint,
                        Feedback = tempMFC[i].FeedBack.ToString("F1"),
                        Ramping = tempMFC[i].Ramping.ToString("F1"),
                        AlarmTable = string.IsNullOrEmpty(tempMFC[i].AlarmWatchTable) ? "None" : tempMFC[i].AlarmWatchTable,
                        MaxValue = (double)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{tempMFC[i].DeviceName}.N2Scale")
                    });
                }
            }
            else
            {
                for (int i = 0; i < tempMFC.Count; i++)
                {
                    var Unit = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{mfcData[i].DeviceName}.FlowUnit");
                    var setpoint = tempMFC[i].SetPoint.ToString("F1");
                    MFCDetailDatas[i].Name = tempMFC[i].DeviceName;
                    MFCDetailDatas[i].DisplayName = tempMFC[i].DisplayName;
                    MFCDetailDatas[i].Unit = Unit;
                    MFCDetailDatas[i].Setpoint = setpoint;
                    MFCDetailDatas[i].Feedback = tempMFC[i].FeedBack.ToString();
                    MFCDetailDatas[i].Ramping = tempMFC[i].Ramping.ToString();
                    MFCDetailDatas[i].AlarmTable = string.IsNullOrEmpty(tempMFC[i].AlarmWatchTable) ? "None" : tempMFC[i].AlarmWatchTable;
                }
            }

            if (MFMDetailDatas.Count == 0)
            {
                for (int i = 0; i < tempMFM.Count; i++)
                {
                    var Unit = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.MFM.{tempMFM[i].DeviceName}.FlowUnit");
                    MFMDetailDatas.Add(new MFMDetailValue()
                    {
                        Name = tempMFM[i].DeviceName,
                        DisplayName = tempMFM[i].DisplayName,
                        Unit = Unit,
                        Setpoint = tempMFM[i].SetPoint.ToString("F1"),
                        Feedback = tempMFM[i].FeedBack.ToString("F1"),
                        AlarmTable = string.IsNullOrEmpty(tempMFM[i].AlarmWatchTable) ? "None" : tempMFM[i].AlarmWatchTable,
                    });
                }
            }
            else
            {
                for (int i = 0; i < tempMFM.Count; i++)
                {
                    var Unit = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.MFM.{tempMFM[i].DeviceName}.FlowUnit");
                    MFMDetailDatas[i].Name = tempMFM[i].DeviceName;
                    MFMDetailDatas[i].DisplayName = tempMFM[i].DeviceName;
                    MFMDetailDatas[i].Unit = Unit;
                    MFMDetailDatas[i].Setpoint = tempMFM[i].SetPoint.ToString("F1");
                    MFMDetailDatas[i].Feedback = tempMFM[i].FeedBack.ToString("F1");
                    MFMDetailDatas[i].AlarmTable = string.IsNullOrEmpty(tempMFM[i].AlarmWatchTable) ? "None" : tempMFM[i].AlarmWatchTable;
                }
            }

            if (ValveDetailDatas.Count == 0)
            {
                for (int i = 0; i < valveData.Count; i++)
                {
                    ValveDetailDatas.Add(new ValveDetailValue()
                    {
                        Name = valveData[i].DeviceName,
                        DisplayName = valveData[i].DisplayName,
                        Feedback = valveData[i].Feedback,
                        Value = valveData[i].IsOpen ? "Open" : "Close",
                        IsEnable = IsEnableMannual,
                    });
                }
            }
            else
            {
                for (int i = 0; i < valveData.Count; i++)
                {
                    ValveDetailDatas[i].Name = valveData[i].DeviceName;
                    ValveDetailDatas[i].DisplayName = valveData[i].DisplayName;
                    ValveDetailDatas[i].Feedback = valveData[i].Feedback;
                    ValveDetailDatas[i].Value = valveData[i].IsOpen ? "Open" : "Close";
                    ValveDetailDatas[i].IsEnable = IsEnableMannual;
                }
            }

            //if (APCDetailDatas.Count == 0)
            //{
            //    for (int i = 0; i < apcData.Count; i++)
            //    {
            //        APCDetailDatas.Add(new MFMDetailValue()
            //        {
            //            Name = apcData[i].DeviceName,
            //            DisplayName = apcData[i].DisplayName,
            //            Unit = apcData[i].UnitPressure,
            //            Setpoint = apcData[i].PressureSetPoint.ToString("F3"),
            //            Feedback = apcData[i].PressureFeedback.ToString("F3"),
            //            AlarmTable = string.IsNullOrEmpty(apcData[i].AlarmWatchTable) ? "None" : apcData[i].AlarmWatchTable,
            //        });
            //    }

            //    APCDetailDatas.Add(new MFMDetailValue()
            //    {
            //        Name = VG2Pressure.DeviceName,
            //        DisplayName = VG2Pressure.DisplayName,
            //        Unit = VG2Pressure.Unit,
            //        Setpoint = "0.000",
            //        Feedback = VG2Pressure.FeedBack.ToString("F3"),
            //        AlarmTable = "None",
            //    });
            //}
            //else
            //{
            //    for (int i = 0; i < apcData.Count - 1; i++)
            //    {
            //        APCDetailDatas[i].Name = apcData[i].DeviceName;
            //        APCDetailDatas[i].DisplayName = apcData[i].DisplayName;
            //        APCDetailDatas[i].Unit = apcData[i].UnitPressure;
            //        APCDetailDatas[i].Setpoint = apcData[i].PressureSetPoint.ToString("F3");
            //        APCDetailDatas[i].Feedback = apcData[i].PressureFeedback.ToString("F3");
            //        APCDetailDatas[i].AlarmTable = string.IsNullOrEmpty(apcData[i].AlarmWatchTable) ? "None" : apcData[i].AlarmWatchTable;
            //    }
            //    APCDetailDatas[1].Name = VG2Pressure.DeviceName;
            //    APCDetailDatas[1].DisplayName = VG2Pressure.DisplayName;
            //    APCDetailDatas[1].Unit = VG2Pressure.Unit;
            //    APCDetailDatas[1].Feedback = VG2Pressure.FeedBack.ToString("F3");
            //}

            //if (AnalogDetailDatas.Count == 0)
            //{
            //    for (int i = 0; i < analogData.Count; i++)
            //    {
            //        AnalogDetailDatas.Add(new AnalogDetailValue()
            //        {
            //            Name = analogData[i].DeviceName,
            //            DisplayName = analogData[i].DisplayName,
            //            Unit = analogData[i].Unit,
            //            Feedback = analogData[i].FeedBack.ToString("F3"),
            //        });
            //    }
            //}
            //else
            //{
            //    for (int i = 0; i < analogData.Count; i++)
            //    {
            //        AnalogDetailDatas[i].Name = analogData[i].DeviceName;
            //        AnalogDetailDatas[i].DisplayName = analogData[i].DisplayName;
            //        AnalogDetailDatas[i].Unit = analogData[i].Unit;
            //        AnalogDetailDatas[i].Feedback = analogData[i].FeedBack.ToString("F3");
            //    }
            //}
        }

        public void MFCSetCmd(object senderName, object sender, object typeName,double maxValue)
        {
            string name = senderName.ToString();
            var control = (Button)sender;
            switch (typeName.ToString())
            {
                case "Setpoint":
                    var windowManager = IoC.Get<IWindowManager>();
                    RecipeFlowSettingViewModel recipeFlowSettingViewModel = new RecipeFlowSettingViewModel();
                    recipeFlowSettingViewModel.SelectMfcFlow = name.ToUpper();
                    recipeFlowSettingViewModel.SelectFlowValue = control.Content.ToString();
                    recipeFlowSettingViewModel.MaxValue = maxValue;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeFlowSettingViewModel, null, "GasDetail Flow Setting"))
                    {
                        MFCDetailDatas.Where(x => x.Name == name).FirstOrDefault().Setpoint = recipeFlowSettingViewModel.SelectFlow;
                    }
                    break;
                case "Ramping":
                    string strRetValue = ShowNumberKeyboard(sender as Button, "");
                    if (strRetValue != "Cancel")
                    {
                        MFCDetailDatas.Where(x => x.Name == name).FirstOrDefault().Ramping = strRetValue;
                    }
                    break;
                case "AlarmTable":
                    RecipeGASSettingMFCAlarmViewModel view = new RecipeGASSettingMFCAlarmViewModel(MFCDetailDatas.Where(x => x.Name == name).FirstOrDefault().AlarmTable);
                    WindowManager wm = IoC.Get<IWindowManager>() as WindowManager;
                    if (!(bool)wm.ShowDialogWithTitle(view, null, "Select Flow Alarm Table")) break;
                    MFCDetailDatas.Where(x => x.Name == name).FirstOrDefault().AlarmTable = view.CurrentValue;
                    break;
            }
        }

        public void MFMSetCmd(object senderName, object sender, object typeName)
        {
            string name = senderName.ToString();
            switch (typeName.ToString())
            {
                case "Setpoint":
                    string strRetValue = ShowNumberKeyboard(sender as Button, "");
                    if (strRetValue != "Cancel")
                    {
                        MFMDetailDatas.Where(x => x.Name == name).FirstOrDefault().Setpoint = strRetValue;
                    }
                    break;
                case "AlarmTable":
                    RecipeGASSettingMFCAlarmViewModel view = new RecipeGASSettingMFCAlarmViewModel(MFMDetailDatas.Where(x => x.Name == name).FirstOrDefault().AlarmTable);
                    WindowManager wm = IoC.Get<IWindowManager>() as WindowManager;
                    if (!(bool)wm.ShowDialogWithTitle(view, null, "Select Flow Alarm Table")) break;
                    MFMDetailDatas.Where(x => x.Name == name).FirstOrDefault().AlarmTable = view.CurrentValue;
                    break;
            }
        }

        public void ValveSetCmd(object senderName)
        {
            string name = senderName.ToString();
            SwitchDialog dlg = new SwitchDialog();
            dlg.IsOpen = ValveDetailDatas.Where(x => x.Name == name).FirstOrDefault().Value == "Open";
            dlg.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            dlg.ShowDialog();
            if (dlg.IsSave)
            {
                ValveDetailDatas.Where(x => x.Name == name).FirstOrDefault().Value = dlg.IsOpen ? "Open" : "Close";
            }
        }

        public void APCSetCmd(object senderName, object sender, object typeName)
        {
            string name = senderName.ToString();
            switch (typeName.ToString())
            {
                case "Setpoint":
                    string strRetValue = ShowNumberKeyboard(sender as Button, "");
                    if (strRetValue != "Cancel")
                    {
                        APCDetailDatas.Where(x => x.Name == name).FirstOrDefault().Setpoint = strRetValue;
                    }
                    break;
                case "AlarmTable":
                    RecipeGASSettingMFCAlarmViewModel view = new RecipeGASSettingMFCAlarmViewModel(APCDetailDatas.Where(x => x.Name == name).FirstOrDefault().AlarmTable);
                    WindowManager wm = IoC.Get<IWindowManager>() as WindowManager;
                    if (!(bool)wm.ShowDialogWithTitle(view, null, "Select Flow Alarm Table")) break;
                    APCDetailDatas.Where(x => x.Name == name).FirstOrDefault().AlarmTable = view.CurrentValue;
                    break;
            }
        }

        private string ShowNumberKeyboard(Control control, string defaultValue)
        {
            NumberKeyboard numberKeyboard = new NumberKeyboard("", defaultValue);
            var point = control.PointFromScreen(new Point(0, 0));
            double wx = SystemParameters.WorkArea.Width;
            double hy = SystemParameters.WorkArea.Height;
            if (-point.Y + control.ActualHeight + 5 + numberKeyboard.Height < hy)
            {
                numberKeyboard.Top = -point.Y + control.ActualHeight + 5;
            }
            else
            {
                numberKeyboard.Top = -point.Y - numberKeyboard.Height - 5;
            }
            if (-point.X + numberKeyboard.Width < wx)
            {
                numberKeyboard.Left = -point.X;
            }
            else
            {
                numberKeyboard.Left = -point.X - (numberKeyboard.Width - control.ActualWidth);
            }
            if ((bool)numberKeyboard.ShowDialog())
                return numberKeyboard.ValueString;
            else
                return "Cancel";
        }

        public void GASSettingSelectCmd(string cmd)
        {
            GridMFCVisibility = Visibility.Hidden;
            GridMFMVisibility = Visibility.Hidden;
            GridValveVisibility = Visibility.Hidden;
            GridAPCVisibility = Visibility.Hidden;
            GridAnalogVisibility = Visibility.Hidden;
            switch (cmd)
            {
                case "MFC":
                    GridMFCVisibility = Visibility.Visible;
                    break;
                case "MFM":
                    GridMFMVisibility = Visibility.Visible;
                    break;
                case "Valve":
                    GridValveVisibility = Visibility.Visible;
                    break;
                case "APC":
                    GridAPCVisibility = Visibility.Visible;
                    break;
                case "Analog":
                    GridAnalogVisibility = Visibility.Visible;
                    break;
                default:
                    break;
            }
        }

        public void MannualSelectCmd()
        {
            _mannualSelectCount++;
            if (_mannualSelectCount % 2 == 0)
            {
                IsEnableMannual = false;
            }
            else
            {
                IsEnableMannual = true;
            }
            UpdateFlowValue();
        }

        public void ExecCmd()
        {
            if (!DialogBox.Confirm("Ara you sure to execute?"))
                return;

            for (int i = 0; i < MFCDetailDatas.Count; i++)
            {
                InvokeClient.Instance.Service.DoOperation($"CHM.{MFCDetailDatas[i].Name}.SetMfcValue", $"{MFCDetailDatas[i].Setpoint};{MFCDetailDatas[i].Ramping};{MFCDetailDatas[i].AlarmTable}");
            }
            for (int i = 0; i < MFMDetailDatas.Count; i++)
            {
                InvokeClient.Instance.Service.DoOperation($"CHM.{MFMDetailDatas[i].Name}.SetMfmValue", $"{MFMDetailDatas[i].Setpoint};{MFMDetailDatas[i].AlarmTable}");
            }
            for (int i = 0; i < ValveDetailDatas.Count; i++)
            {
                InvokeClient.Instance.Service.DoOperation($"CHM.{ValveDetailDatas[i].Name}.{AITValveOperation.GVTurnValve}", ValveDetailDatas[i].Value == "Open");
            }
            _mannualSelectCount = 0;
            IsEnableMannual = false;
        }

        public void CloseCmd()
        {
            ((Window)GetView()).DialogResult = false;
        }
    }

    public class AnalogDetailValue : PropertyChangedBase
    {
        private string _name;

        public string Name
        {
            get => _name;
            set
            {
                _name = value;
                NotifyOfPropertyChange("Name");
            }
        }

        private string _displayName;

        public string DisplayName
        {
            get => _displayName;
            set
            {
                _displayName = value;
                NotifyOfPropertyChange("DisplayName");
            }
        }

        public string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange("Unit");
            }
        }

        private string _feedback;

        public string Feedback
        {
            get => _feedback;
            set
            {
                _feedback = value;
                NotifyOfPropertyChange("Feedback");
            }
        }
    }

    public class ValveDetailValue : PropertyChangedBase
    {
        private string _name;

        public string Name
        {
            get => _name;
            set
            {
                _name = value;
                NotifyOfPropertyChange("Name");
            }
        }

        private string _displayName;

        public string DisplayName
        {
            get => _displayName;
            set
            {
                _displayName = value;
                NotifyOfPropertyChange("DisplayName");
            }
        }

        private string _value;
        public string Value
        {
            get => _value;
            set
            {
                _value = value;
                NotifyOfPropertyChange("Value");
            }
        }

        private bool _feedback;
        public bool Feedback
        {
            get => _feedback;
            set
            {
                _feedback = value;
                NotifyOfPropertyChange("Feedback");
            }
        }

        private bool _isEnable=true;
        public bool IsEnable
        {
            get => _isEnable;
            set
            {
                _isEnable = value;
                NotifyOfPropertyChange("IsEnable");
            }
        }
    }

    public class MFMDetailValue : PropertyChangedBase
    {
        private string _name;

        public string Name
        {
            get => _name;
            set
            {
                _name = value;
                NotifyOfPropertyChange("Name");
            }
        }

        private string _displayName;

        public string DisplayName
        {
            get => _displayName;
            set
            {
                _displayName = value;
                NotifyOfPropertyChange("DisplayName");
            }
        }

        public string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange("Unit");
            }
        }

        private string _setpoint;

        public string Setpoint
        {
            get => _setpoint;
            set
            {
                _setpoint = value;
                NotifyOfPropertyChange("Setpoint");
            }
        }

        private string _feedback;

        public string Feedback
        {
            get => _feedback;
            set
            {
                _feedback = value;
                NotifyOfPropertyChange("Feedback");
            }
        }

        private string _alarmTable;

        public string AlarmTable
        {
            get => _alarmTable; set
            {
                _alarmTable = value;
                NotifyOfPropertyChange("AlarmTable");
            }
        }
    }

    public class MFCDetailValue : PropertyChangedBase
    {
        private string _name;

        public string Name
        {
            get => _name;
            set
            {
                _name = value;
                NotifyOfPropertyChange("Name");
            }
        }

        private string _displayName;

        public string DisplayName
        {
            get => _displayName;
            set
            {
                _displayName = value;
                NotifyOfPropertyChange("DisplayName");
            }
        }

        public string _unit;

        public string Unit
        {
            get => _unit;
            set
            {
                _unit = value;
                NotifyOfPropertyChange("Unit");
            }
        }

        private string _setpoint;

        public string Setpoint
        {
            get => _setpoint;
            set
            {
                _setpoint = value;
                NotifyOfPropertyChange("Setpoint");
            }
        }

        private string _feedback;

        public string Feedback
        {
            get => _feedback;
            set
            {
                _feedback = value;
                NotifyOfPropertyChange("Feedback");
            }
        }

        private string _ramping;

        public string Ramping
        {
            get => _ramping; 
            set
            {
                _ramping = value;
                NotifyOfPropertyChange("Ramping");
            }
        }

        private string _alarmTable;

        public string AlarmTable
        {
            get => _alarmTable; set
            {
                _alarmTable = value;
                NotifyOfPropertyChange("AlarmTable");
            }
        }

        private double _maxValue;

        public double MaxValue 
        {
            get { return _maxValue; }
            set { 
                _maxValue = value;
                NotifyOfPropertyChange("MaxValue");
            }
        }
    }
}