FurnaceELK/Furnace/FurnaceUI/Views/Editors/ELK/RecipeGasPanelSettingViewModel.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.UI.ControlDataContext;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
using FurnaceUI.Models;
using MECF.Framework.Common.OperationCenter;

using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FurnaceUI.Views.Recipes;
using System.Windows.Input;
using System.Windows;
using Aitex.Core.UI.DeviceControl;
using OpenSEMI.ClientBase;
using Aitex.Core.UI.Control;
using MECF.Framework.UI.Core.Control;
using MECF.Framework.UI.Core.ExtendedControls;
using System.Reflection;
namespace FurnaceUI.Views.Editors.ELK
{
    public class RecipeGasPanelSettingViewModel : FurnaceUIViewModelBase, IDisposable
    {
        public Window WinOwner { get; set; }
        public bool IsCEXHOn { get; set; }
        public string CEXHBrush
        {
            get
            {
                if (IsCEXHOn)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }
        public bool IsF2ClnOn { get; set; }
        public string F2ClnBrush
        {
            get
            {
                if (IsF2ClnOn)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }
        public bool IsDEPOOn { get; set; }
        public string DEPOBrush
        {
            get
            {
                if (IsDEPOOn)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }
        //[Subscription("PM1.IsHFClnOn")]
        public bool IsHFClnOn { get; set; }
        public string HFClnBrush
        {
            get
            {
                if (IsHFClnOn)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.ValveBlowerPowerOn.DeviceData")]
        public AITValveData ValveBWR { get; set; }
        public string ValveBWRBrush
        {
            get
            {
                if (ValveBWR != null && ValveBWR.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        //[Subscription("PM1.HTR1Enable")]
        public bool IsHTR1Enable { get; set; }
        public string HTR1Brush
        {
            get
            {
                if (IsHTR1Enable)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }
        //[Subscription("PM1.HTR2Enable")]
        public bool IsHTR2Enable { get; set; }
        public string HTR2Brush
        {
            get
            {
                if (IsHTR2Enable)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        public bool IsHTR3Enable { get; set; }
        public string HTR3Brush
        {
            get
            {
                if (IsHTR3Enable)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }
        
        public bool IsDPRON { get; set; }
        public string ValveDPRBrush
        {
            get
            {
                if (IsDPRON)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.AUCPump.DeviceData")]
        public AITValveData AUCPump { get; set; }
        public string AUCPumpBrush
        {
            get
            {
                if (AUCPump != null && AUCPump.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.BothPump1.DeviceData")]
        public AITValveData BothPump1 { get; set; }
        public string BothPump1Brush
        {
            get
            {
                if (BothPump1 != null && BothPump1.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.BothPump2.DeviceData")]
        public AITValveData BothPump2 { get; set; }
        public string BothPump2Brush
        {
            get
            {
                if (BothPump2 != null && BothPump2.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.AGVPump.DeviceData")]
        public AITValveData AGVPump { get; set; }
        public string AGVPumpBrush
        {
            get
            {
                if (AGVPump != null && AGVPump.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.AGV2Pump.DeviceData")]
        public AITValveData AGV2Pump { get; set; }
        public string AGV2PumpBrush
        {
            get
            {
                if (AGV2Pump != null && AGV2Pump.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.HMNT.DeviceData")]
        public AITValveData HMNT { get; set; }

        public string HMNTBrush
        {
            get
            {
                if (HMNT != null && HMNT.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.CMNT.DeviceData")]
        public AITValveData CMNT { get; set; }
        public string CMNTBrush
        {
            get
            {
                if (CMNT != null && CMNT.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.HREF.DeviceData")]
        public AITValveData HREF { get; set; }
        public string HREFBrush
        {
            get
            {
                if (HREF != null && HREF.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.CREF.DeviceData")]
        public AITValveData CREF2 { get; set; }
        public string CREF2Brush
        {
            get
            {
                if (CREF2 != null && CREF2.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.HZERO.DeviceData")]
        public AITValveData HZERO { get; set; }
        public string HZEROBrush
        {
            get
            {
                if (HZERO != null && HZERO.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.CZERO.DeviceData")]
        public AITValveData CZERO { get; set; }
        public string CZEROBrush
        {
            get
            {
                if (CZERO != null && CZERO.VirtualFeedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }


        public bool IsEnable => CGlobal.RecipeProcessEditViewEnable;//是否是View模式
        public bool _ismanagerPermission = true;
        public bool IsManagerPermission
        {
            get
            {
                return _ismanagerPermission;
            }
            set
            {
                _ismanagerPermission = value;
                NotifyOfPropertyChange("IsManagerPermission");
            }
        }
        #region Valves
        [Subscription("PM1.ValveAV1.DeviceData")] public AITValveData ValveAV1 { get; set; }
        [Subscription("PM1.ValveAV2.DeviceData")] public AITValveData ValveAV2 { get; set; }
        [Subscription("PM1.ValveAV3.DeviceData")] public AITValveData ValveAV3 { get; set; }
        [Subscription("PM1.ValveAV4.DeviceData")] public AITValveData ValveAV4 { get; set; }
        [Subscription("PM1.ValveAV5.DeviceData")] public AITValveData ValveAV5 { get; set; }
        [Subscription("PM1.ValveAV6.DeviceData")] public AITValveData ValveAV6 { get; set; }
        [Subscription("PM1.ValveAV7.DeviceData")] public AITValveData ValveAV7 { get; set; }
        [Subscription("PM1.ValveAV8.DeviceData")] public AITValveData ValveAV8 { get; set; }
        [Subscription("PM1.ValveAV9.DeviceData")] public AITValveData ValveAV9 { get; set; }

        [Subscription("PM1.ValveAV10.DeviceData")] public AITValveData ValveAV10 { get; set; }
        [Subscription("PM1.ValveAV11.DeviceData")] public AITValveData ValveAV11 { get; set; }
        [Subscription("PM1.ValveAV12.DeviceData")] public AITValveData ValveAV12 { get; set; }
        [Subscription("PM1.ValveAV13.DeviceData")] public AITValveData ValveAV13 { get; set; }
        [Subscription("PM1.ValveAV14.DeviceData")] public AITValveData ValveAV14 { get; set; }
        [Subscription("PM1.ValveAV15.DeviceData")] public AITValveData ValveAV15 { get; set; }
        [Subscription("PM1.ValveAV16.DeviceData")] public AITValveData ValveAV16 { get; set; }
        [Subscription("PM1.ValveAV17.DeviceData")] public AITValveData ValveAV17 { get; set; }
        [Subscription("PM1.ValveAV18.DeviceData")] public AITValveData ValveAV18 { get; set; }
        [Subscription("PM1.ValveAV19.DeviceData")] public AITValveData ValveAV19 { get; set; }

        [Subscription("PM1.ValveAV20.DeviceData")] public AITValveData ValveAV20 { get; set; }
        [Subscription("PM1.ValveAV21.DeviceData")] public AITValveData ValveAV21 { get; set; }
        [Subscription("PM1.ValveAV22.DeviceData")] public AITValveData ValveAV22 { get; set; }
        [Subscription("PM1.ValveAV23.DeviceData")] public AITValveData ValveAV23 { get; set; }
        [Subscription("PM1.ValveAV24.DeviceData")] public AITValveData ValveAV24 { get; set; }
        [Subscription("PM1.ValveAV25.DeviceData")] public AITValveData ValveAV25 { get; set; }
        [Subscription("PM1.ValveAV26.DeviceData")] public AITValveData ValveAV26 { get; set; }
        [Subscription("PM1.ValveAV27.DeviceData")] public AITValveData ValveAV27 { get; set; }
        [Subscription("PM1.ValveAV28.DeviceData")] public AITValveData ValveAV28 { get; set; }
        [Subscription("PM1.ValveAV29.DeviceData")] public AITValveData ValveAV29 { get; set; }

        [Subscription("PM1.ValveAV30.DeviceData")] public AITValveData ValveAV30 { get; set; }
        [Subscription("PM1.ValveAV31.DeviceData")] public AITValveData ValveAV31 { get; set; }
        [Subscription("PM1.ValveAV32.DeviceData")] public AITValveData ValveAV32 { get; set; }
        [Subscription("PM1.ValveAV33.DeviceData")] public AITValveData ValveAV33 { get; set; }
        [Subscription("PM1.ValveAV34.DeviceData")] public AITValveData ValveAV34 { get; set; }
        [Subscription("PM1.ValveAV35.DeviceData")] public AITValveData ValveAV35 { get; set; }
        [Subscription("PM1.ValveAV36.DeviceData")] public AITValveData ValveAV36 { get; set; }
        [Subscription("PM1.ValveAV37.DeviceData")] public AITValveData ValveAV37 { get; set; }
        [Subscription("PM1.ValveAV38.DeviceData")] public AITValveData ValveAV38 { get; set; }
        [Subscription("PM1.ValveAV39.DeviceData")] public AITValveData ValveAV39 { get; set; }

        [Subscription("PM1.ValveAV40.DeviceData")] public AITValveData ValveAV40 { get; set; }
        [Subscription("PM1.ValveAV41.DeviceData")] public AITValveData ValveAV41 { get; set; }
        [Subscription("PM1.ValveAV42.DeviceData")] public AITValveData ValveAV42 { get; set; }
        [Subscription("PM1.ValveAV43.DeviceData")] public AITValveData ValveAV43 { get; set; }
        [Subscription("PM1.ValveAV44.DeviceData")] public AITValveData ValveAV44 { get; set; }
        [Subscription("PM1.ValveAV45.DeviceData")] public AITValveData ValveAV45 { get; set; }
        [Subscription("PM1.ValveAV46.DeviceData")] public AITValveData ValveAV46 { get; set; }
        [Subscription("PM1.ValveAV47.DeviceData")] public AITValveData ValveAV47 { get; set; }
        [Subscription("PM1.ValveAV48.DeviceData")] public AITValveData ValveAV48 { get; set; }
        [Subscription("PM1.ValveAV49.DeviceData")] public AITValveData ValveAV49 { get; set; }

        [Subscription("PM1.ValveAV50.DeviceData")] public AITValveData ValveAV50 { get; set; }
        [Subscription("PM1.ValveAV51.DeviceData")] public AITValveData ValveAV51 { get; set; }
        [Subscription("PM1.ValveAV52.DeviceData")] public AITValveData ValveAV52 { get; set; }
        [Subscription("PM1.ValveAV53.DeviceData")] public AITValveData ValveAV53 { get; set; }
        [Subscription("PM1.ValveAV54.DeviceData")] public AITValveData ValveAV54 { get; set; }
        [Subscription("PM1.ValveAV55.DeviceData")] public AITValveData ValveAV55 { get; set; }
        [Subscription("PM1.ValveAV56.DeviceData")] public AITValveData ValveAV56 { get; set; }
        [Subscription("PM1.ValveAV57.DeviceData")] public AITValveData ValveAV57 { get; set; }
        [Subscription("PM1.ValveAV58.DeviceData")] public AITValveData ValveAV58 { get; set; }
        [Subscription("PM1.ValveAV59.DeviceData")] public AITValveData ValveAV59 { get; set; }

        [Subscription("PM1.ValveAV60.DeviceData")] public AITValveData ValveAV60 { get; set; }
        [Subscription("PM1.ValveAV61.DeviceData")] public AITValveData ValveAV61 { get; set; }
        [Subscription("PM1.ValveAV62.DeviceData")] public AITValveData ValveAV62 { get; set; }

        [Subscription("PM1.ValveAV65.DeviceData")] public AITValveData ValveAV65 { get; set; }
        [Subscription("PM1.ValveAV66.DeviceData")] public AITValveData ValveAV66 { get; set; }
        [Subscription("PM1.ValveAV67.DeviceData")] public AITValveData ValveAV67 { get; set; }
        [Subscription("PM1.ValveAV68.DeviceData")] public AITValveData ValveAV68 { get; set; }
        [Subscription("PM1.ValveAV69.DeviceData")] public AITValveData ValveAV69 { get; set; }

        [Subscription("PM1.ValveAV70.DeviceData")] public AITValveData ValveAV70 { get; set; }
        [Subscription("PM1.APC.ModeFeedback")]
        public int APCModeFeedback { get; set; }
        [Subscription("PM1.ValveAV71.DeviceData")] public AITValveData ValveAV71Data { get; set; }
        public AITValveData ValveAV71
        {
            get
            {
                return new AITValveData()
                {
                    DeviceName = ValveAV71Data.DeviceName,
                    DisplayName = ValveAV71Data.DisplayName,
                    UniqueName = ValveAV71Data.UniqueName,
                    DefaultValue = ValveAV71Data.DefaultValue,
                    SetPoint = ValveAV71Data.SetPoint,
                    Feedback = APCModeFeedback != 5,
                    VirtualFeedback = ValveAV71Data.VirtualFeedback
                };
            }
        }
        [Subscription("PM1.ValveAV72.DeviceData")] public AITValveData ValveAV72 { get; set; }
        [Subscription("PM1.ValveAV73.DeviceData")] public AITValveData ValveAV73 { get; set; }
        [Subscription("PM1.ValveAV74.DeviceData")] public AITValveData ValveAV74 { get; set; }
        [Subscription("PM1.ValveAV75.DeviceData")] public AITValveData ValveAV75 { get; set; }
        [Subscription("PM1.ValveAV76.DeviceData")] public AITValveData ValveAV76 { get; set; }
        [Subscription("PM1.ValveAV77.DeviceData")] public AITValveData ValveAV77 { get; set; }
        [Subscription("PM1.ValveAV78.DeviceData")] public AITValveData ValveAV78 { get; set; }
        [Subscription("PM1.ValveAV79.DeviceData")] public AITValveData ValveAV79 { get; set; }

        [Subscription("PM1.ValveAV80.DeviceData")] public AITValveData ValveAV80 { get; set; }
        [Subscription("PM1.ValveAV81.DeviceData")] public AITValveData ValveAV81 { get; set; }
        [Subscription("PM1.ValveAV82.DeviceData")] public AITValveData ValveAV82 { get; set; }
        [Subscription("PM1.ValveAV83.DeviceData")] public AITValveData ValveAV83 { get; set; }
        [Subscription("PM1.ValveAV84.DeviceData")] public AITValveData ValveAV84 { get; set; }
        [Subscription("PM1.ValveAV85.DeviceData")] public AITValveData ValveAV85 { get; set; }
        [Subscription("PM1.ValveAV86.DeviceData")] public AITValveData ValveAV86 { get; set; }
        [Subscription("PM1.ValveAV87.DeviceData")] public AITValveData ValveAV87 { get; set; }
        [Subscription("PM1.ValveAV88.DeviceData")] public AITValveData ValveAV88 { get; set; }
        [Subscription("PM1.ValveAV89.DeviceData")] public AITValveData ValveAV89 { get; set; }

        [Subscription("PM1.ValveAV90.DeviceData")] public AITValveData ValveAV90 { get; set; }
        [Subscription("PM1.ValveAV91.DeviceData")] public AITValveData ValveAV91 { get; set; }
        [Subscription("PM1.ValveAV92.DeviceData")] public AITValveData ValveAV92 { get; set; }
        [Subscription("PM1.ValveAV93.DeviceData")] public AITValveData ValveAV93 { get; set; }
        [Subscription("PM1.ValveAV94.DeviceData")] public AITValveData ValveAV94 { get; set; }
        [Subscription("PM1.ValveAV95.DeviceData")] public AITValveData ValveAV95 { get; set; }
        [Subscription("PM1.ValveAV96.DeviceData")] public AITValveData ValveAV96 { get; set; }
        [Subscription("PM1.ValveAV97.DeviceData")] public AITValveData ValveAV97 { get; set; }
        [Subscription("PM1.ValveAV98.DeviceData")] public AITValveData ValveAV98 { get; set; }
        [Subscription("PM1.ValveAV99.DeviceData")] public AITValveData ValveAV99 { get; set; }

        [Subscription("PM1.ValveAV100.DeviceData")] public AITValveData ValveAV100 { get; set; }
        [Subscription("PM1.ValveAV101.DeviceData")] public AITValveData ValveAV101 { get; set; }
        [Subscription("PM1.ValveAV102.DeviceData")] public AITValveData ValveAV102 { get; set; }
        [Subscription("PM1.ValveAV103.DeviceData")] public AITValveData ValveAV103 { get; set; }
        [Subscription("PM1.ValveAV104.DeviceData")] public AITValveData ValveAV104 { get; set; }
        [Subscription("PM1.ValveAV105.DeviceData")] public AITValveData ValveAV105 { get; set; }
        [Subscription("PM1.ValveAV106.DeviceData")] public AITValveData ValveAV106 { get; set; }
        [Subscription("PM1.ValveAV107.DeviceData")] public AITValveData ValveAV107 { get; set; }
        [Subscription("PM1.ValveAV108.DeviceData")] public AITValveData ValveAV108 { get; set; }
        [Subscription("PM1.ValveAV109.DeviceData")] public AITValveData ValveAV109 { get; set; }

        [Subscription("PM1.ValveAV110.DeviceData")] public AITValveData ValveAV110 { get; set; }
        [Subscription("PM1.ValveAV111.DeviceData")] public AITValveData ValveAV111 { get; set; }
        [Subscription("PM1.ValveAV112.DeviceData")] public AITValveData ValveAV112 { get; set; }
        [Subscription("PM1.ValveAV113.DeviceData")] public AITValveData ValveAV113 { get; set; }
        [Subscription("PM1.ValveAV114.DeviceData")] public AITValveData ValveAV114 { get; set; }
        [Subscription("PM1.ValveAV115.DeviceData")] public AITValveData ValveAV115 { get; set; }
        [Subscription("PM1.ValveAV116.DeviceData")] public AITValveData ValveAV116 { get; set; }
        [Subscription("PM1.ValveAV117.DeviceData")] public AITValveData ValveAV117 { get; set; }
        [Subscription("PM1.ValveAV118.DeviceData")] public AITValveData ValveAV118 { get; set; }
        [Subscription("PM1.ValveAV119.DeviceData")] public AITValveData ValveAV119 { get; set; }

        [Subscription("PM1.ValveAV120.DeviceData")] public AITValveData ValveAV120 { get; set; }
        [Subscription("PM1.ValveAV121.DeviceData")] public AITValveData ValveAV121 { get; set; }
        [Subscription("PM1.ValveAV122.DeviceData")] public AITValveData ValveAV122 { get; set; }
        [Subscription("PM1.ValveAV123.DeviceData")] public AITValveData ValveAV123 { get; set; }
        [Subscription("PM1.ValveAV124.DeviceData")] public AITValveData ValveAV124 { get; set; }
        [Subscription("PM1.ValveAV125.DeviceData")] public AITValveData ValveAV125 { get; set; }
        [Subscription("PM1.ValveAV126.DeviceData")] public AITValveData ValveAV126 { get; set; }
        [Subscription("PM1.ValveAV127.DeviceData")] public AITValveData ValveAV127 { get; set; }
        [Subscription("PM1.ValveAV128.DeviceData")] public AITValveData ValveAV128 { get; set; }
        [Subscription("PM1.ValveAV129.DeviceData")] public AITValveData ValveAV129 { get; set; }

        [Subscription("PM1.ValveAV130.DeviceData")] public AITValveData ValveAV130 { get; set; }
        [Subscription("PM1.ValveAV131.DeviceData")] public AITValveData ValveAV131 { get; set; }
        [Subscription("PM1.ValveAV132.DeviceData")] public AITValveData ValveAV132 { get; set; }
        [Subscription("PM1.ValveAV133.DeviceData")] public AITValveData ValveAV133 { get; set; }
        [Subscription("PM1.ValveAV134.DeviceData")] public AITValveData ValveAV134 { get; set; }
        [Subscription("PM1.ValveAV135.DeviceData")] public AITValveData ValveAV135 { get; set; }
        [Subscription("PM1.ValveAV136.DeviceData")] public AITValveData ValveAV136 { get; set; }
        #endregion
        [Subscription("PM1.SensorPureN2PressureOK.DeviceData")]
        public AITSensorData SensorPureN2PressureOK { get; set; }
        [Subscription("PM1.SensorNH3PressureOK.DeviceData")]
        public AITSensorData SensorNH3PressureOK { get; set; }
        [Subscription("PM1.SensorSiH2CL2PressureOK.DeviceData")]
        public AITSensorData SensorSiH2CL2PressureOK { get; set; }
        [Subscription("PM1.SensorN2OPressureOK.DeviceData")]
        public AITSensorData SensorN2OPressureOK { get; set; }
        [Subscription("PM1.SensorPSW1LOW.DeviceData")]
        public AITSensorData SensorPSW1LOW { get; set; }
        [Subscription("PM1.SensorPSW2LOW.DeviceData")]
        public AITSensorData SensorPSW2LOW { get; set; }
        [Subscription("PM1.SensorGUExhaustOK.DeviceData")]
        public AITSensorData SensorGUExhaustOK { get; set; }
        [Subscription("PM1.SensorVAC1.Value")]
        public bool VAC1 { get; set; }
        [Subscription("PM1.SensorVAC2.Value")]
        public bool VAC2 { get; set; }
        [Subscription("PM1.SensorVAC3.Value")]
        public bool VAC3 { get; set; }
        [Subscription("PM1.SensorVAC4.Value")]
        public bool VAC4 { get; set; }
        [Subscription("PM1.SensorVAC5.Value")]
        public bool VAC5 { get; set; }
        [Subscription("PM1.SensorVAC6.Value")]
        public bool VAC6 { get; set; }
        [Subscription("PM1.SensorVAC7.Value")]
        public bool VAC7 { get; set; }
        [Subscription("PM1.SensorVAC8.Value")]
        public bool VAC8 { get; set; }

        [Subscription("PM1.SensorVACATM.Value")]
        public bool VACATM { get; set; }
        [Subscription("PM1.SensorVACDEPOOK.Value")]
        public bool DEPOOK { get; set; }
        [Subscription("PM1.SensorVACHFOK.Value")]
        public bool HFClnOK { get; set; }
        [Subscription("PM1.SensorVACF2OK.Value")]
        public bool F2ClnOK { get; set; }

        [Subscription("PM1.SensorHCDTANKHH.Value")]
        public bool HCDTANKHH { get; set; }

        [Subscription("PM1.SensorHCDTANKH.Value")]
        public bool HCDTANKH { get; set; }

        [Subscription("PM1.SensorHCDTANKM.Value")]
        public bool HCDTANKM { get; set; }

        [Subscription("PM1.SensorHCDTANKL.Value")]
        public bool HCDTANKL { get; set; }

        [Subscription("PM1.SensorCSOURCETANKHH.Value")]
        public bool CSOURCETANKHH { get; set; }

        [Subscription("PM1.SensorCSOURCETANKH.Value")]
        public bool CSOURCETANKH { get; set; }

        [Subscription("PM1.SensorCSOURCETANKM.Value")]
        public bool CSOURCETANKM { get; set; }

        [Subscription("PM1.SensorCSOURCETANKL.Value")]
        public bool CSOURCETANKL { get; set; }

        [Subscription("PM1.SensorLDS1SystemReady.Value")]
        public bool LDS1SystemReady { get; set; }

        [Subscription("PM1.SensorLDS2SystemReady.Value")]
        public bool LDS2SystemReady { get; set; }

        [Subscription("PM1.SensorDEPOOKILK.Value")]
        public bool SensorDEPOOKILK { get; set; }

        [Subscription("PM1.SensorCLNOKILK.Value")]
        public bool SensorCLNOKILK { get; set; }

        [Subscription("PM1.SensorNVAC.Value")]
        public bool SensorNVAC { get; set; }


        [Subscription("PM1.SensorHREFILK.Value")]
        public bool SensorHREFILK { get; set; }

        [Subscription("PM1.SensorCREFILK.Value")]
        public bool SensorCREFILK { get; set; }

        #region MFCs
        [Subscription("PM1.MFC1.DeviceData")]
        public AITMfcData MFC1Data { get; set; }
        [Subscription("PM1.MFC2.DeviceData")]
        public AITMfcData MFC2Data { get; set; }
        [Subscription("PM1.MFC3.DeviceData")]
        public AITMfcData MFC3Data { get; set; }
        [Subscription("PM1.MFC4.DeviceData")]
        public AITMfcData MFC4Data { get; set; }
        [Subscription("PM1.MFC5.DeviceData")]
        public AITMfcData MFC5Data { get; set; }
        [Subscription("PM1.MFC6.DeviceData")]
        public AITMfcData MFC6Data { get; set; }
        [Subscription("PM1.MFC7.DeviceData")]
        public AITMfcData MFC7Data { get; set; }
        [Subscription("PM1.MFC8.DeviceData")]
        public AITMfcData MFC8Data { get; set; }
        [Subscription("PM1.MFC9.DeviceData")]
        public AITMfcData MFC9Data { get; set; }
        [Subscription("PM1.MFC10.DeviceData")]
        public AITMfcData MFC10Data { get; set; }
        [Subscription("PM1.MFC11.DeviceData")]
        public AITMfcData MFC11Data { get; set; }
        [Subscription("PM1.MFC12.DeviceData")]
        public AITMfcData MFC12Data { get; set; }
        [Subscription("PM1.MFC13.DeviceData")]
        public AITMfcData MFC13Data { get; set; }
        [Subscription("PM1.MFC16.DeviceData")]
        public AITMfcData MFC16Data { get; set; }
        [Subscription("PM1.MFC17.DeviceData")]
        public AITMfcData MFC17Data { get; set; }

        [Subscription("PM1.MFC31.DeviceData")]
        public AITMfcData MFC31Data { get; set; }

        [Subscription("PM1.MFC32.DeviceData")]
        public AITMfcData MFC32Data { get; set; }

        [Subscription("PM1.MFM6.DeviceData")]
        public AITWaterFlowMeterData MFM6FlowData { get; set; }
        [Subscription("PM1.MFM7.DeviceData")]
        public AITWaterFlowMeterData MFM7FlowData { get; set; }
        [Subscription("PM1.MFM8.DeviceData")]
        public AITWaterFlowMeterData MFM8FlowData { get; set; }
        [Subscription("PM1.MFM9.DeviceData")]
        public AITWaterFlowMeterData MFM9FlowData { get; set; }
        [Subscription("PM1.MFM11.DeviceData")]
        public AITWaterFlowMeterData MFM11FlowData { get; set; }
        [Subscription("PM1.MFM12.DeviceData")]
        public AITWaterFlowMeterData MFM12FlowData { get; set; }
        [Subscription("PM1.MFM13.DeviceData")]
        public AITWaterFlowMeterData MFM13FlowData { get; set; }
        [Subscription("PM1.MFM16.DeviceData")]
        public AITWaterFlowMeterData MFM16FlowData { get; set; }
        #endregion


        public ICommand CmdSetValve { get; set; }
        public ICommand CmdSetMfcFlow { get; set; }
        public ICommand CmdSetMfmFlow { get; set; }
        public int SelectedStepNo { get; set; }

        private string _selectedStepName;

        public string SelectedStepName
        {
            get
            {
                return _selectedStepName;
            }
            set
            {
                _selectedStepName = value;
                NotifyOfPropertyChange("SelectedStepName");
            }
        }

        private Step _step;

        public Step SelectedStep
        {
            get => _step;
            set
            {
                _step = value;
                NotifyOfPropertyChange("SelectedStep");
            }
        }

        public RecipeDataBase CurrentRecipe { get; set; }

        #region"MFC"
        private AnalogDeviceDataItem _mfc1;

        public AnalogDeviceDataItem MFC1
        {
            get => _mfc1;
            set
            {
                _mfc1 = value;
                NotifyOfPropertyChange("MFC1");
            }
        }

        private AnalogDeviceDataItem _mfc2;

        public AnalogDeviceDataItem MFC2
        {
            get => _mfc2;
            set
            {
                _mfc2 = value;
                NotifyOfPropertyChange("MFC2");
            }
        }


        private AnalogDeviceDataItem _mfc3;

        public AnalogDeviceDataItem MFC3
        {
            get => _mfc3;
            set
            {
                _mfc3 = value;
                NotifyOfPropertyChange("MFC3");
            }
        }

        private AnalogDeviceDataItem _mfc4;

        public AnalogDeviceDataItem MFC4
        {
            get => _mfc4;
            set
            {
                _mfc4 = value;
                NotifyOfPropertyChange("MFC4");
            }
        }

        private AnalogDeviceDataItem _mfc5;

        public AnalogDeviceDataItem MFC5
        {
            get => _mfc5;
            set
            {
                _mfc5 = value;
                NotifyOfPropertyChange("MFC5");
            }
        }

        private AnalogDeviceDataItem _mfc6;

        public AnalogDeviceDataItem MFC6
        {
            get => _mfc6;
            set
            {
                _mfc6 = value;
                NotifyOfPropertyChange("MFC6");
            }
        }

        private AnalogDeviceDataItem _mfc7;

        public AnalogDeviceDataItem MFC7
        {
            get => _mfc7;
            set
            {
                _mfc7 = value;
                NotifyOfPropertyChange("MFC7");
            }
        }

        private AnalogDeviceDataItem _mfc8;

        public AnalogDeviceDataItem MFC8
        {
            get => _mfc8;
            set
            {
                _mfc8 = value;
                NotifyOfPropertyChange("MFC8");
            }
        }

        private AnalogDeviceDataItem _mfc9;

        public AnalogDeviceDataItem MFC9
        {
            get => _mfc9;
            set
            {
                _mfc9 = value;
                NotifyOfPropertyChange("MFC9");
            }
        }

        private AnalogDeviceDataItem _mfc10;

        public AnalogDeviceDataItem MFC10
        {
            get => _mfc10;
            set
            {
                _mfc10 = value;
                NotifyOfPropertyChange("MFC10");
            }
        }

        private AnalogDeviceDataItem _mfc11;

        public AnalogDeviceDataItem MFC11
        {
            get => _mfc11;
            set
            {
                _mfc11 = value;
                NotifyOfPropertyChange("MFC11");
            }
        }

        private AnalogDeviceDataItem _mfc12;

        public AnalogDeviceDataItem MFC12
        {
            get => _mfc12;
            set
            {
                _mfc12 = value;
                NotifyOfPropertyChange("MFC12");
            }
        }
        private AnalogDeviceDataItem _mfc13;
        public AnalogDeviceDataItem MFC13
        {
            get => _mfc13;
            set
            {
                _mfc13 = value;
                NotifyOfPropertyChange("MFC13");
            }
        }

        private AnalogDeviceDataItem _mfc16;
        public AnalogDeviceDataItem MFC16
        {
            get => _mfc16;
            set
            {
                _mfc16 = value;
                NotifyOfPropertyChange("MFC16");
            }
        }
        private AnalogDeviceDataItem _mfc17;
        public AnalogDeviceDataItem MFC17
        {
            get => _mfc17;
            set
            {
                _mfc17 = value;
                NotifyOfPropertyChange("MFC17");
            }
        }
        private AnalogDeviceDataItem _mfc31;
        public AnalogDeviceDataItem MFC31
        {
            get => _mfc31;
            set
            {
                _mfc31 = value;
                NotifyOfPropertyChange("MFC31");
            }
        }
        private AnalogDeviceDataItem _mfc32;
        public AnalogDeviceDataItem MFC32
        {
            get => _mfc32;
            set
            {
                _mfc32 = value;
                NotifyOfPropertyChange("MFC32");
            }
        }
        #endregion

        private AnalogDeviceDataItem _MFM6;

        public AnalogDeviceDataItem MFM6
        {
            get => _MFM6;
            set
            {
                _MFM6 = value;
                NotifyOfPropertyChange("MFM6");
            }
        }
        private AnalogDeviceDataItem _MFM7;

        public AnalogDeviceDataItem MFM7
        {
            get => _MFM7;
            set
            {
                _MFM7 = value;
                NotifyOfPropertyChange("MFM7");
            }
        }
        private AnalogDeviceDataItem _MFM8;

        public AnalogDeviceDataItem MFM8
        {
            get => _MFM8;
            set
            {
                _MFM8 = value;
                NotifyOfPropertyChange("MFM8");
            }
        }
        private AnalogDeviceDataItem _MFM9;

        public AnalogDeviceDataItem MFM9
        {
            get => _MFM9;
            set
            {
                _MFM9 = value;
                NotifyOfPropertyChange("MFM9");
            }
        }
        private AnalogDeviceDataItem _MFM11;

        public AnalogDeviceDataItem MFM11
        {
            get => _MFM11;
            set
            {
                _MFM11 = value;
                NotifyOfPropertyChange("MFM11");
            }
        }
        private AnalogDeviceDataItem _MFM12;

        public AnalogDeviceDataItem MFM12
        {
            get => _MFM12;
            set
            {
                _MFM12 = value;
                NotifyOfPropertyChange("MFM12");
            }
        }
        private AnalogDeviceDataItem _MFM13;

        public AnalogDeviceDataItem MFM13
        {
            get => _MFM13;
            set
            {
                _MFM13 = value;
                NotifyOfPropertyChange("MFM13");
            }
        }
        private AnalogDeviceDataItem _MFM16;

        public AnalogDeviceDataItem MFM16
        {
            get => _MFM16;
            set
            {
                _MFM16 = value;
                NotifyOfPropertyChange("MFM16");
            }
        }

        public delegate void ChangedStepHandler(Step step);

        public event ChangedStepHandler ChangedStepEvent;

        private bool _isUsePREVBtn = false;

        public bool IsUsePREVBtn
        {
            get => _isUsePREVBtn;
            set
            {
                _isUsePREVBtn = value;
                NotifyOfPropertyChange("IsUsePREVBtn");
            }
        }

        private bool _isUseNEXTBtn = false;

        public bool IsUseNEXTBtn
        {
            get => _isUseNEXTBtn;
            set
            {
                _isUseNEXTBtn = value;
                NotifyOfPropertyChange("IsUseNEXTBtn");
            }
        }

        private GasPanelStateType _selectedGasStateType = GasPanelStateType.Monitor;

        public GasPanelStateType SelectedGasStateType
        {
            get
            {
                return _selectedGasStateType;
            }
            set
            {
                _selectedGasStateType = value;
                NotifyOfPropertyChange(nameof(SelectedGasStateType));
            }
        }

        private void SetPREVAndNEXTBtn()
        {
            if (SelectedStep != null && CurrentRecipe != null)
            {
                if (CurrentRecipe.Steps.Count == 0)
                {
                    IsUsePREVBtn = false;
                    IsUseNEXTBtn = false;
                }
                else
                {
                    if (SelectedStep.StepNo > CurrentRecipe.Steps[0].StepNo)
                    {
                        IsUsePREVBtn = true;
                    }
                    else
                    {
                        IsUsePREVBtn = false;
                    }
                    if (SelectedStep.StepNo < CurrentRecipe.Steps[CurrentRecipe.Steps.Count - 1].StepNo)
                    {
                        IsUseNEXTBtn = true;
                    }
                    else
                    {
                        IsUseNEXTBtn = false;
                    }
                }

            }
        }

        public void SetChangedStep(Step step)
        {
            if (ChangedStepEvent != null)
            {
                ChangedStepEvent(step);
            }
        }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            IsManagerPermission = true;
            SetValveVirtualFeedbackValue();
            // CreateAITValveDataDefault();
            CreateMfcDefault();
            CreateMfmDefault();
            SetPREVAndNEXTBtn();
            CmdSetValve = new DelegateCommand<object>(SetValveCommand);
            CmdSetMfcFlow = new DelegateCommand<object>(PerformCmdSetMfcFlow);
            CmdSetMfmFlow = new DelegateCommand<object>(PerformCmdSetMfmFlow);
            SelectedGasStateType = GasPanelStateType.Recipe;
            ((RecipeGasPanelSettingView)view).RdoRecipe.IsChecked = true;
        }

        public void SetValveCommand(object param)
        {
            object[] args = (object[])param;
            if (args.Length == 3)

                if (SelectedStep.ValveSets.FirstOrDefault(x => x.Name == (string)args[0]) != null)
                {
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == (string)args[0]).SetValue((bool)args[2]);
                    //InvokeClient.Instance.Service.DoOperation($"{args[0]}.{args[1]}", args[2]);
                }
        }

        public void SelectedGasStateTypeCmd(string cmd)
        {
            switch (cmd)
            {
                case "Manual":
                    SelectedGasStateType = GasPanelStateType.Manual;
                    break;
                case "Monitor":
                    SelectedGasStateType = GasPanelStateType.Monitor;
                    break;
                case "Recipe":
                    SelectedGasStateType = GasPanelStateType.Recipe;
                    break;
                default:
                    break;
            }
        }

        private void PerformCmdSetMfcFlow(object param)
        {
            object[] args = (object[])param; //0:devicename, 1:operation, 2:args
            if (args.Length == 3)
            {
                InvokeClient.Instance.Service.DoOperation($"{args[0]}.{args[1]}", args[2]);
                if (SelectedStep != null)
                {
                    var mfc = SelectedStep.MFCSets.FirstOrDefault(x => x.ControlName == ((string)args[0]).Replace("PM1.", ""));
                    if (mfc != null)
                    {
                        mfc.SetValue.SetValue(args[2].ToString());
                    }
                }
            }
        }
        private void PerformCmdSetMfmFlow(object param)
        {
            object[] args = (object[])param; //0:devicename, 1:operation, 2:args
            if (args.Length == 3)
            {
                InvokeClient.Instance.Service.DoOperation($"PM1.{args[0]}.{args[1]}", args[2]);
            }
        }

        public AnalogDeviceDataItem AITMfcDataToAnalogDeviceDataItem(AITMfcData aITMfcData)
        {
            string mfcStrValue = "0.00";
            var mfcData = SelectedStep.MFCSets?.FirstOrDefault(x => x.ControlName == aITMfcData.DeviceName);
            if (mfcData != null)
            {
                mfcStrValue = mfcData.SetValue.Value;
            }
            else
            {
                Console.WriteLine(aITMfcData.DeviceName);
            }
            return new AnalogDeviceDataItem
            {
                Type = aITMfcData.Type,
                DeviceName = aITMfcData.UniqueName,
                DeviceId = aITMfcData.DeviceSchematicId,
                DisplayName = aITMfcData.DisplayName,
                Scale = aITMfcData.Scale,
                Unit = aITMfcData.Unit,
                FeedBack = double.Parse(mfcStrValue),
                SetPoint = double.Parse(mfcStrValue),
                VirtualFeedBack = double.Parse(mfcStrValue),
            };

        }
        public AnalogDeviceDataItem AITMfMDataToAnalogDeviceDataItem(AITWaterFlowMeterData mfmData)
        {
            return new AnalogDeviceDataItem()
            {
                Type = mfmData.Type,
                Unit = mfmData.Unit,
                DeviceId = mfmData.DeviceSchematicId,
                DefaultValue = mfmData.DefaultValue,
                Description = mfmData.Description,
                DeviceName = mfmData.DeviceName,
                DisplayName = mfmData.DisplayName,
                ErroMessage = mfmData.ErroMessage,
                Factor = mfmData.Factor,
                FeedBack = mfmData.FeedBack,
                Scale = mfmData.Scale,
                SetPoint = mfmData.SetPoint,
                IsWarning = mfmData.IsWarning,
                FormatString = "F2"
            };

        }
        public AnalogDeviceDataItem UpdateAITMfcDataToAnalogDeviceDataItem(AITMfcData aITMfcData)
        {
            var strtemp = $"{aITMfcData.DeviceName}.Flow";
            string mfcStrValue = "0.00";

            return new AnalogDeviceDataItem
            {
                Type = aITMfcData.Type,
                DeviceName = aITMfcData.UniqueName,
                DeviceId = aITMfcData.DeviceSchematicId,
                DisplayName = aITMfcData.DisplayName,
                Scale = aITMfcData.Scale,
                Unit = aITMfcData.Unit,
                FeedBack = SelectedGasStateType == GasPanelStateType.Monitor ? aITMfcData.FeedBack : aITMfcData.SetPoint,
                SetPoint = double.Parse(mfcStrValue),
                VirtualFeedBack = aITMfcData.VirtualFeedBack,
                IsCharge = true
            };
        }


        public void CreateMfcDefault()
        {
            MFC1 = AITMfcDataToAnalogDeviceDataItem(MFC1Data);
            MFC2 = AITMfcDataToAnalogDeviceDataItem(MFC2Data);
            MFC3 = AITMfcDataToAnalogDeviceDataItem(MFC3Data);
            MFC4 = AITMfcDataToAnalogDeviceDataItem(MFC4Data);
            MFC5 = AITMfcDataToAnalogDeviceDataItem(MFC5Data);
            MFC6 = AITMfcDataToAnalogDeviceDataItem(MFC6Data);
            MFC7 = AITMfcDataToAnalogDeviceDataItem(MFC7Data);
            MFC8 = AITMfcDataToAnalogDeviceDataItem(MFC8Data);
            MFC9 = AITMfcDataToAnalogDeviceDataItem(MFC9Data);
            MFC10 = AITMfcDataToAnalogDeviceDataItem(MFC10Data);
            MFC11 = AITMfcDataToAnalogDeviceDataItem(MFC11Data);
            MFC12 = AITMfcDataToAnalogDeviceDataItem(MFC12Data);
            MFC13 = AITMfcDataToAnalogDeviceDataItem(MFC13Data);
            MFC16 = AITMfcDataToAnalogDeviceDataItem(MFC16Data);
            MFC17 = AITMfcDataToAnalogDeviceDataItem(MFC17Data);
            MFC31 = AITMfcDataToAnalogDeviceDataItem(MFC31Data);
            MFC32 = AITMfcDataToAnalogDeviceDataItem(MFC32Data);
        }

        public void CreateMfmDefault()
        {
            MFM6 = AITMfMDataToAnalogDeviceDataItem(MFM6FlowData);
            MFM7 = AITMfMDataToAnalogDeviceDataItem(MFM7FlowData);
            MFM8 = AITMfMDataToAnalogDeviceDataItem(MFM8FlowData);
            MFM9 = AITMfMDataToAnalogDeviceDataItem(MFM9FlowData);
            MFM11 = AITMfMDataToAnalogDeviceDataItem(MFM11FlowData);
            MFM12 = AITMfMDataToAnalogDeviceDataItem(MFM12FlowData);
            MFM13 = AITMfMDataToAnalogDeviceDataItem(MFM13FlowData);
            MFM16 = AITMfMDataToAnalogDeviceDataItem(MFM16FlowData);
        }




        public void SetValveVirtualFeedbackValue()
        {
            Dictionary<string, bool> dictValve = new Dictionary<string, bool>();
            foreach (var item in SelectedStep.ValveSets)
            {
                dictValve[item.Name] = item.Value;
            }
            InvokeClient.Instance.Service.DoOperation($"PM1.SetAll{AITValveOperation.GVVirtualTurnValve}", dictValve);

            foreach (var item in SelectedStep.ValveSets)
            {
                switch (item.Name.ToUpper())
                {
                    case "AGV":
                        if (AGVPump != null) InvokeClient.Instance.Service.DoOperation($"{AGVPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "AGV2":
                        if (AGV2Pump != null) InvokeClient.Instance.Service.DoOperation($"{AGV2Pump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "DP1":
                        if (BothPump1 != null) InvokeClient.Instance.Service.DoOperation($"{BothPump1.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "DP2":
                        if (BothPump2 != null) InvokeClient.Instance.Service.DoOperation($"{BothPump2.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "BWR":
                        if (ValveBWR != null) InvokeClient.Instance.Service.DoOperation($"{ValveBWR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "ValveAV93":
                        //if (ValveDPR != null) InvokeClient.Instance.Service.DoOperation($"{ValveDPR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "HMNT":
                        if (HMNT != null) InvokeClient.Instance.Service.DoOperation($"{HMNT.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "CMNT":
                        if (CMNT != null) InvokeClient.Instance.Service.DoOperation($"{CMNT.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "HREF":
                        if (HREF != null) InvokeClient.Instance.Service.DoOperation($"{HREF.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "CREF":
                        if (CREF2 != null) InvokeClient.Instance.Service.DoOperation($"{CREF2.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "HZERO":
                        if (HZERO != null) InvokeClient.Instance.Service.DoOperation($"{HZERO.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "CZERO":
                        if (CZERO != null) InvokeClient.Instance.Service.DoOperation($"{CZERO.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", item.Value);
                        break;
                    case "DPR":
                        IsDPRON = item.Value;
                        break;
                    case "CEXH":
                        IsCEXHOn = item.Value;
                        break;
                    case "DEPO":
                        IsDEPOOn = item.Value;
                        break;
                    case "F2CLN":
                        IsF2ClnOn = item.Value;
                        break;
                    case "HFCLN":
                        IsHFClnOn = item.Value;
                        break;
                    case "HTR1":
                        IsHTR1Enable = item.Value;
                        break;
                    case "HTR2":
                        IsHTR2Enable = item.Value;
                        break;
                    case "HTR3":
                        IsHTR3Enable = item.Value;
                        break;
                    default:
                        break;
                }
            }
        }


        public void StepClick(string cmd)
        {
            bool isChangedStep = false;

            switch (cmd)
            {
                case "PREV":
                    SelectedStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedStep.StepNo - 1).FirstOrDefault();
                    isChangedStep = true;
                    break;

                case "NEXT":
                    SelectedStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedStep.StepNo + 1).FirstOrDefault();
                    isChangedStep = true;
                    break;
                default:
                    break;
            }
            SelectedStepName = $"{SelectedStep.StepNo}:{SelectedStep.Name}";
            if (isChangedStep && SelectedStep != null)
            {
                SetChangedStep(SelectedStep);
            }
            SetPREVAndNEXTBtn();
            // CreateAITValveDataDefault();
            SetValveVirtualFeedbackValue();
            CreateMfcDefault();
            CreateMfmDefault();
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            MFCChangedUpdate();
            if (SelectedGasStateType == GasPanelStateType.Recipe)
            {
                PropertyInfo[] tempProperties = GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
                foreach (PropertyInfo property in tempProperties)
                {
                    if (property.Name.Contains("MFC"))
                    {
                        // 触发属性更改通知
                        NotifyOfPropertyChange(property.Name);
                    }
                }
            }
        }

        private void MFCChangedUpdate()
        {
            if (MFC1.VirtualFeedBack != MFC1Data.VirtualFeedBack || MFC1.FeedBack != MFC1Data.FeedBack)
            {
                MFC1 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC1Data);
            }
            if (MFC2.VirtualFeedBack != MFC2Data.VirtualFeedBack || MFC2.FeedBack != MFC2Data.FeedBack)
            {
                MFC2 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC2Data);
            }
            if (MFC3.VirtualFeedBack != MFC3Data.VirtualFeedBack || MFC3.FeedBack != MFC3Data.FeedBack)
            {
                MFC3 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC3Data);
            }
            if (MFC4.VirtualFeedBack != MFC4Data.VirtualFeedBack || MFC4.FeedBack != MFC4Data.FeedBack)
            {
                MFC4 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC4Data);
            }
            if (MFC5.VirtualFeedBack != MFC5Data.VirtualFeedBack || MFC5.FeedBack != MFC5Data.FeedBack)
            {
                MFC5 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC5Data);
            }
            if (MFC6.VirtualFeedBack != MFC6Data.VirtualFeedBack || MFC6.FeedBack != MFC6Data.FeedBack)
            {
                MFC6 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC6Data);
            }
            if (MFC7.VirtualFeedBack != MFC7Data.VirtualFeedBack || MFC7.FeedBack != MFC7Data.FeedBack)
            {
                MFC7 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC7Data);
            }
            if (MFC8.VirtualFeedBack != MFC8Data.VirtualFeedBack || MFC8.FeedBack != MFC8Data.FeedBack)
            {
                MFC8 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC8Data);
            }
            if (MFC9.VirtualFeedBack != MFC9Data.VirtualFeedBack || MFC9.FeedBack != MFC9Data.FeedBack)
            {
                MFC9 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC9Data);
            }
            if (MFC10.VirtualFeedBack != MFC10Data.VirtualFeedBack || MFC10.FeedBack != MFC10Data.FeedBack)
            {
                MFC10 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC10Data);
            }
            if (MFC11.VirtualFeedBack != MFC11Data.VirtualFeedBack || MFC11.FeedBack != MFC11Data.FeedBack)
            {
                MFC11 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC11Data);
            }
            if (MFC12.VirtualFeedBack != MFC12Data.VirtualFeedBack || MFC12.FeedBack != MFC12Data.FeedBack)
            {
                MFC12 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC12Data);
            }
            if (MFC13.VirtualFeedBack != MFC13Data.VirtualFeedBack || MFC13.FeedBack != MFC13Data.FeedBack)
            {
                MFC13 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC13Data);
            }
            if (MFC16.VirtualFeedBack != MFC16Data.VirtualFeedBack || MFC16.FeedBack != MFC16Data.FeedBack)
            {
                MFC16 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC16Data);
            }
            if (MFC17.VirtualFeedBack != MFC17Data.VirtualFeedBack || MFC17.FeedBack != MFC17Data.FeedBack)
            {
                MFC17 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC17Data);
            }
            if (MFC31.VirtualFeedBack != MFC31Data.VirtualFeedBack || MFC31.FeedBack != MFC31Data.FeedBack)
            {
                MFC31 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC31Data);
            }
            if (MFC32.VirtualFeedBack != MFC32Data.VirtualFeedBack || MFC32.FeedBack != MFC32Data.FeedBack)
            {
                MFC32 = UpdateAITMfcDataToAnalogDeviceDataItem(MFC32Data);
            }
        }

        public void TempSetSave()
        {

            foreach (var item in SelectedStep.ValveSets)
            {
                switch (item.Name)
                {
                    case "AGV":
                        item.Value = AGVPump.VirtualFeedback;
                        break;
                    case "AGV2":
                        item.Value = AGV2Pump.VirtualFeedback;
                        break;
                    case "MBP":
                        item.Value = BothPump1.VirtualFeedback;
                        break;
                    case "DP1":
                        item.Value = BothPump1.VirtualFeedback;
                        break;
                    case "DP2":
                        item.Value = BothPump2.VirtualFeedback;
                        break;
                    case "BWR":
                        item.Value = ValveBWR.VirtualFeedback;
                        break;
                    case "ValveAV93":
                        //item.Value = ValveDPR.VirtualFeedback;
                        break;
                    case "DPR":
                        item.Value = IsDPRON;
                        break;
                    case "CEXH":
                        item.Value = IsCEXHOn;
                        break;
                    case "F2Cln":
                        item.Value = IsF2ClnOn;
                        break;
                    case "DEPO":
                        item.Value = IsDEPOOn;
                        break;
                    case "HFCln":
                        item.Value = IsHFClnOn;
                        break;
                    case "HTR1":
                        item.Value = IsHTR1Enable;
                        break;
                    case "HTR2":
                        item.Value = IsHTR2Enable;
                        break;
                    case "HTR3":
                        item.Value = IsHTR3Enable;
                        break;
                    default:
                        break;
                }
            }
            // List<string> mfcKeys = SelectedStep.MFCSets.Keys.ToList();
            foreach (var mfcitem in SelectedStep.MFCSets)
            {
                var replaceStr = mfcitem.ControlName;
                var property = this.GetType().GetProperties().Where(x => x.Name == replaceStr).FirstOrDefault();
                if (property == null) continue;
                object value = property.GetValue(this, null);
                if (value != null)
                {
                    mfcitem.SetValue.Value = (Math.Round(((AnalogDeviceDataItem)value).VirtualFeedBack, 3).ToString(""));
                }
            }
            ((Window)GetView()).DialogResult = true;
        }

        public void SwichValue(string name)
        {
            string setCmd = "";
            bool setValue = false;

            switch (name.ToUpper())
            {
                case "BWR":
                    var valveBwr = !ValveBWR.VirtualFeedback;
                    setValue = valveBwr;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "BWR").SetValue(valveBwr);
                    InvokeClient.Instance.Service.DoOperation($"{ValveBWR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveBwr);
                    setCmd = "BWR";
                    break;
                case "DPR":
                    IsDPRON = !IsDPRON;
                    setValue = IsDPRON;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "DPR").SetValue(IsDPRON);
                    setCmd = "DPR";
                    //var valveDpr = !ValveDPR.VirtualFeedback;
                    //setValue = valveDpr;
                    //SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "ValveAV93").SetValue(valveDpr);
                    //InvokeClient.Instance.Service.DoOperation($"{ValveDPR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveDpr);
                    //setCmd = "ValveAV93";
                    break;
                case "DP1":
                    var valveDP1 = !BothPump1.VirtualFeedback;
                    setValue = valveDP1;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "DP1").SetValue(valveDP1);
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "MBP1").SetValue(valveDP1);
                    InvokeClient.Instance.Service.DoOperation($"{BothPump1.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveDP1);
                    setCmd = "DP1";
                    break;
                case "DP2":
                    var valveDP2 = !BothPump2.VirtualFeedback;
                    setValue = valveDP2;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "DP2").SetValue(valveDP2);
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "MBP2").SetValue(valveDP2);
                    InvokeClient.Instance.Service.DoOperation($"{BothPump2.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveDP2);
                    setCmd = "DP2";
                    break;
                case "AGV1":
                    var valveAGV1 = !AGVPump.VirtualFeedback;
                    setValue = valveAGV1;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "AGV").SetValue(valveAGV1);
                    InvokeClient.Instance.Service.DoOperation($"{AGVPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveAGV1);
                    setCmd = "AGV";
                    break;
                case "AGV2":
                    var valveAGV2 = !AGV2Pump.VirtualFeedback;
                    setValue = valveAGV2;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "AGV2").SetValue(valveAGV2);
                    InvokeClient.Instance.Service.DoOperation($"{AGV2Pump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveAGV2);
                    setCmd = "AGV2";
                    break;
                case "CEXH":
                    IsCEXHOn = !IsCEXHOn;
                    setValue = IsCEXHOn;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "CEXH").SetValue(IsCEXHOn);
                    setCmd = "CEXH";
                    break;
                case "F2":
                    IsF2ClnOn = !IsF2ClnOn;
                    setValue = IsF2ClnOn;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "F2Cln").SetValue(IsF2ClnOn);
                    setCmd = "F2Cln";
                    break;
                case "HF":
                    IsHFClnOn = !IsHFClnOn;
                    setValue = IsHFClnOn;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HFCln").SetValue(IsHFClnOn);
                    setCmd = "HFCln";
                    break;
                case "DEPO":
                    IsDEPOOn = !IsDEPOOn;
                    setValue = IsDEPOOn;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "DEPO").SetValue(IsDEPOOn);
                    setCmd = "DEPO";
                    break;
                case "HMNT":
                    var valveHMNT = !HMNT.VirtualFeedback;
                    setValue = valveHMNT;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HMNT").SetValue(valveHMNT);
                    InvokeClient.Instance.Service.DoOperation($"{HMNT.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveHMNT);
                    setCmd = "HMNT";
                    break;
                case "CMNT":
                    var valveCMNT = !CMNT.VirtualFeedback;
                    setValue = valveCMNT;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "CMNT").SetValue(valveCMNT);
                    InvokeClient.Instance.Service.DoOperation($"{CMNT.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveCMNT);
                    setCmd = "CMNT";
                    break;
                case "HREF":
                    var valveHREF = !HREF.VirtualFeedback;
                    setValue = valveHREF;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HREF").SetValue(valveHREF);
                    InvokeClient.Instance.Service.DoOperation($"{HREF.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveHREF);
                    setCmd = "HREF";
                    break;
                case "CREF2":
                    var valveHREF2 = !CREF2.VirtualFeedback;
                    setValue = valveHREF2;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "CREF").SetValue(valveHREF2);
                    InvokeClient.Instance.Service.DoOperation($"{CREF2.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveHREF2);
                    setCmd = "CREF";
                    break;
                case "HZERO":
                    var valveHZERO = !HZERO.VirtualFeedback;
                    setValue = valveHZERO;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HZERO").SetValue(valveHZERO);
                    InvokeClient.Instance.Service.DoOperation($"{HZERO.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveHZERO);
                    setCmd = "HZERO";
                    break;
                case "CZERO":
                    var valveCZERO = !CZERO.VirtualFeedback;
                    setValue = valveCZERO;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "CZERO").SetValue(valveCZERO);
                    InvokeClient.Instance.Service.DoOperation($"{CZERO.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", valveCZERO);
                    setCmd = "CZERO";
                    break;
            }

            if (!string.IsNullOrEmpty(setCmd))
            {
                SetValveFollow(setCmd, setValue);
            }
        }

        public void SetEnable(string name)
        {
            string setCmd = "";
            bool setValue = false;
            switch (name.ToUpper())
            {
                case "HTR1":
                    IsHTR1Enable = !IsHTR1Enable;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HTR1").SetValue(IsHTR1Enable);
                    setCmd = "HTR1";
                    setValue = IsHTR1Enable;
                    break;
                case "HTR2":
                    IsHTR2Enable = !IsHTR2Enable;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HTR2").SetValue(IsHTR2Enable);
                    setCmd = "HTR2";
                    setValue = IsHTR2Enable;
                    break;
                case "HTR3":
                    IsHTR3Enable = !IsHTR3Enable;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HTR3").SetValue(IsHTR3Enable);
                    setCmd = "HTR3";
                    setValue = IsHTR3Enable;
                    break;
            }
            if (!string.IsNullOrEmpty(setCmd))
            {
                SetValveFollow(setCmd, setValue);
            }
        }

        public void SelectPump(string _pumpname)
        {
            if (_pumpname == "AUC")
            {
                InvokeClient.Instance.Service.DoOperation($"{AUCPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", !AUCPump.VirtualFeedback);
            }

            if (_pumpname == "Both")
            {
                InvokeClient.Instance.Service.DoOperation($"{BothPump1.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", !BothPump1.VirtualFeedback);
            }

        }

        private void SetValveFollow(string controlName, bool value)
        {
            int firstIndex = CurrentRecipe.Steps.IndexOf(SelectedStep);
            if (firstIndex < CurrentRecipe.Steps.Count)
            {
                for (int i = firstIndex + 1; i < CurrentRecipe.Steps.Count; i++)
                {
                    if (!CurrentRecipe.Steps[i].ValveIsSaved)
                    {
                        break;
                    }
                    else
                    {
                        CurrentRecipe.Steps[i].ValveSets.FirstOrDefault(x => x.Name == controlName).Value = value;
                    }
                }
            }
        }

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

        private bool disposed = false;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this); // 防止垃圾回收器再次调用析构函数
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    // 释放托管资源
                }

                // 释放非托管资源

                disposed = true;
            }
        }
    }



}