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

using Aitex.Core.Common.DeviceData;
using Aitex.Core.UI.ControlDataContext;
using Aitex.Core.Util;
using Caliburn.Micro.Core;
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.Models;
using FurnaceUI.Views.Recipes;
using System.Windows.Input;
using Aitex.Core.UI.MVVM;
using MECF.Framework.Common.OperationCenter;
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;

namespace FurnaceUI.Views.Editors
{
    public class RecipeGasPanelSettingViewModel : FurnaceUIViewModelBase
    {
        public Window WinOwner { get; set; }
        //[Subscription("PM1.IsF2ClnOn")]
        public bool IsF2ClnOn { get; set; }
        public string F2ClnBrush
        {
            get
            {
                if (IsF2ClnOn)
                {
                    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";
            }
        }

        [Subscription("PM1.ValveAV91.DeviceData")]
        public AITValveData ValveDPR { get; set; }
        public string ValveDPRBrush
        {
            get
            {
                if (ValveDPR != null && ValveDPR.VirtualFeedback)
                {
                    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.BothPump.DeviceData")]
        public AITValveData BothPump { get; set; }
        public string BothPumpBrush
        {
            get
            {
                if (BothPump != null && BothPump.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";
            }
        }

        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.ValveAV52.DeviceData")]
        public AITValveData ValveAV52 { get; set; }
        //[Subscription("PM1.ValveAV54.DeviceData")]
        //public AITValveData ValveAV54 { 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.ValveFIMS1N2Purge.DeviceData")]
        //public AITValveData ValveAV63 { get; set; }
        //[Subscription("PM1.ValveFIMS2N2Purge.DeviceData")]
        //public AITValveData ValveAV64 { get; set; }
        //[Subscription("PM1.ValveAV65.DeviceData")]
        //public AITValveData ValveAV65 { get; set; }
        //[Subscription("PM1.ValveAV66.DeviceData")]
        //public AITValveData ValveAV66 { get; set; }
        //[Subscription("PM1.ValveAV68.DeviceData")]
        //public AITValveData ValveAV68 { 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.ValveAV77.DeviceData")]
        public AITValveData ValveAV77 { 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.ValveAV91.DeviceData")]
        public AITValveData ValveAV91 { 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; }
        #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.MFC51.DeviceData")]
        public AITMfcData MFC51Data { get; set; }
        #endregion

        [Subscription("PM1.MfmD1.DeviceData")]
        public AITWaterFlowMeterData MfmD1FlowData { get; set; }

        public ICommand CmdSetValve { get; set; }
        public ICommand CmdSetMfcFlow { 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 _mfc51;

        //public AnalogDeviceDataItem MFC51
        //{
        //    get => _mfc51;
        //    set
        //    {
        //        _mfc51 = value;
        //        NotifyOfPropertyChange("MFC51");
        //    }
        //}
        #endregion

        private AnalogDeviceDataItem _mfmD1Flow;

        public AnalogDeviceDataItem MfmD1Flow
        {
            get => _mfmD1Flow;
            set
            {
                _mfmD1Flow = value;
                NotifyOfPropertyChange("MfmD1Flow");
            }
        }

        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();
            SetPREVAndNEXTBtn();
            CmdSetValve = new DelegateCommand<object>(SetValveCommand);
            CmdSetMfcFlow = new DelegateCommand<object>(PerformCmdSetMfcFlow);
            SelectedGasStateType = GasPanelStateType.Recipe;
            ((RecipeGasPanelSettingView)view).RdoRecipe.IsChecked = true;
        }

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

                if (SelectedStep != null && SelectedStep.ValveSets.Count > 0 && 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]);
            }
        }

        public AnalogDeviceDataItem AITMfcDataToAnalogDeviceDataItem(AITMfcData aITMfcData)
        {
            var strtemp = $"{aITMfcData.DeviceName}.Flow";
            string mfcStrValue = "0.00";
            mfcStrValue = SelectedStep.MFCSets.FirstOrDefault(x => x.ControlName == aITMfcData.DeviceName)?.SetValue.Value;
            //if (SelectedStep != null && SelectedStep.MFCSets.ContainsKey(strtemp))
            //{
            //    mfcStrValue = SelectedStep.MFCSets[strtemp].SetValueParam.Value;
            //}
            //else
            //{
            //    Console.WriteLine(strtemp);
            //}
            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 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,
            };
        }


        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);
            //MFC51 = AITMfcDataToAnalogDeviceDataItem(MFC51Data);
        }

        public void CreateMfmDefault()
        {
            MfmD1Flow = new AnalogDeviceDataItem()
            {
                Type = MfmD1FlowData.Type,
                Unit = MfmD1FlowData.Unit,
                DefaultValue = MfmD1FlowData.DefaultValue,
                Description = MfmD1FlowData.Description,
                DeviceName = MfmD1FlowData.DeviceName,
                DisplayName = MfmD1FlowData.DisplayName,
                ErroMessage = MfmD1FlowData.ErroMessage,
                Factor = MfmD1FlowData.Factor,
                FeedBack = MfmD1FlowData.FeedBack,
                Scale = MfmD1FlowData.Scale,
                SetPoint = MfmD1FlowData.SetPoint,
                IsWarning = MfmD1FlowData.IsWarning,
                FormatString = "F2"
            };

            //  AITWaterFlowMeterData MfmD1Flow
        }




        public void SetValveVirtualFeedbackValue()
        {
            //if (ValveAV1 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV1.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV1.DeviceName.Trim()] == "Open"); }
            //if (ValveAV2 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV2.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV2.DeviceName.Trim()] == "Open"); }
            //if (ValveAV3 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV3.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV3.DeviceName.Trim()] == "Open"); }
            //if (ValveAV4 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV4.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV4.DeviceName.Trim()] == "Open"); }
            //if (ValveAV5 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV5.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV5.DeviceName.Trim()] == "Open"); }
            //if (ValveAV6 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV6.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV6.DeviceName.Trim()] == "Open"); }
            //if (ValveAV7 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV7.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV7.DeviceName.Trim()] == "Open"); }
            //if (ValveAV8 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV8.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV8.DeviceName.Trim()] == "Open"); }
            //if (ValveAV9 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV9.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV9.DeviceName.Trim()] == "Open"); }
            //if (ValveAV10 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV10.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV10.DeviceName.Trim()] == "Open"); }
            //if (ValveAV11 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV11.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV11.DeviceName.Trim()] == "Open"); }
            //if (ValveAV12 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV12.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV12.DeviceName.Trim()] == "Open"); }
            //if (ValveAV13 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV13.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV13.DeviceName.Trim()] == "Open"); }
            //if (ValveAV14 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV14.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV14.DeviceName.Trim()] == "Open"); }
            //if (ValveAV15 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV15.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV15.DeviceName.Trim()] == "Open"); }
            //if (ValveAV16 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV16.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV16.DeviceName.Trim()] == "Open"); }
            //if (ValveAV17 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV17.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV17.DeviceName.Trim()] == "Open"); }
            //if (ValveAV18 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV18.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV18.DeviceName.Trim()] == "Open"); }
            //if (ValveAV19 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV19.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV19.DeviceName.Trim()] == "Open"); }
            //if (ValveAV20 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV20.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV20.DeviceName.Trim()] == "Open"); }
            //if (ValveAV21 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV21.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV21.DeviceName.Trim()] == "Open"); }
            //if (ValveAV22 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV22.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV22.DeviceName.Trim()] == "Open"); }
            //if (ValveAV23 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV23.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV23.DeviceName.Trim()] == "Open"); }
            //if (ValveAV24 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV24.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV24.DeviceName.Trim()] == "Open"); }
            //if (ValveAV25 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV25.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV25.DeviceName.Trim()] == "Open"); }
            //if (ValveAV26 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV26.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV26.DeviceName.Trim()] == "Open"); }
            //if (ValveAV27 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV27.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV27.DeviceName.Trim()] == "Open"); }
            //if (ValveAV28 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV28.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV28.DeviceName.Trim()] == "Open"); }
            //if (ValveAV29 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV29.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV29.DeviceName.Trim()] == "Open"); }
            //if (ValveAV30 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV30.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV30.DeviceName.Trim()] == "Open"); }
            //if (ValveAV31 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV31.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV31.DeviceName.Trim()] == "Open"); }
            //if (ValveAV32 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV32.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV32.DeviceName.Trim()] == "Open"); }
            //if (ValveAV33 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV33.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV33.DeviceName.Trim()] == "Open"); }
            //if (ValveAV34 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV34.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV34.DeviceName.Trim()] == "Open"); }
            //if (ValveAV35 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV35.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV35.DeviceName.Trim()] == "Open"); }
            //if (ValveAV36 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV36.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV36.DeviceName.Trim()] == "Open"); }
            //if (ValveAV37 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV37.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV37.DeviceName.Trim()] == "Open"); }
            //if (ValveAV38 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV38.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV38.DeviceName.Trim()] == "Open"); }
            //if (ValveAV39 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV39.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV39.DeviceName.Trim()] == "Open"); }
            //if (ValveAV52 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV52.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV52.DeviceName.Trim()] == "Open"); }
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV54.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV54.DeviceName.Trim()] == "Open");
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV56.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV56.DeviceName.Trim()] == "Open");
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV57.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV57.DeviceName.Trim()] == "Open");
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV58.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV58.DeviceName.Trim()] == "Open");
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV59.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV59.DeviceName.Trim()] == "Open");
            //if (ValveAV60 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV60.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV60.DeviceName.Trim()] == "Open"); }
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV65.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV65.DeviceName.Trim()] == "Open");
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV66.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV66.DeviceName.Trim()] == "Open");
            ////InvokeClient.Instance.Service.DoOperation($"{ValveAV68.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV68.DeviceName.Trim()] == "Open");


            //if (ValveAV71 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV71.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV71.DeviceName.Trim()] == "Open"); }
            //if (ValveAV72 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV72.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV72.DeviceName.Trim()] == "Open"); }
            //if (ValveAV73 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV73.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV73.DeviceName.Trim()] == "Open"); }
            //if (ValveAV74 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV74.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV74.DeviceName.Trim()] == "Open"); }
            //if (ValveAV75 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV75.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV75.DeviceName.Trim()] == "Open"); }
            //if (ValveAV77 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV77.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV77.DeviceName.Trim()] == "Open"); }
            //if (ValveAV81 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV81.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV81.DeviceName.Trim()] == "Open"); }
            //if (ValveAV82 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV82.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV82.DeviceName.Trim()] == "Open"); }
            //if (ValveAV83 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV83.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets[ValveAV83.DeviceName.Trim()] == "Open"); }

            //if (ValveAV91 != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveAV91.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets["DPR"] == "Open"); }
            //if (AGVPump != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{AGVPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets["AGV"] == "Open"); }
            //if (BothPump != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{BothPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets["MBP"] == "Open"); }
            //if (AUCPump != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{AUCPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets["DP"] == "Open"); }
            //if (ValveBWR != null)
            //{ InvokeClient.Instance.Service.DoOperation($"{ValveBWR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", SelectedStep.ValveSets["BWR"] == "Open"); }
            //if (SelectedStep.ValveSets.ContainsKey("F2Cln"))
            //{
            //    IsF2ClnOn = SelectedStep.ValveSets["F2Cln"] == "Open";
            //}
            //else
            //{
            //    IsF2ClnOn = false;
            //}
            //if (SelectedStep.ValveSets.ContainsKey("HFCln"))
            //{
            //    IsHFClnOn = SelectedStep.ValveSets["HFCln"] == "Open";
            //}
            //else
            //{
            //    IsHFClnOn = false;
            //}
            //if (SelectedStep.ValveSets.ContainsKey("HTR1"))
            //{
            //    if (SelectedStep.ValveSets["HTR1"] == "Close")
            //    {
            //        IsHTR1Enable = false;
            //    }
            //    else
            //    {
            //        IsHTR1Enable = true;
            //    }
            //}
            //else
            //{
            //    IsHTR1Enable = true;
            //}
            //if (SelectedStep.ValveSets.ContainsKey("HTR2"))
            //{
            //    if (SelectedStep.ValveSets["HTR2"] == "Close")
            //    {
            //        IsHTR2Enable = false;
            //    }
            //    else
            //    {
            //        IsHTR2Enable = true;
            //    }
            //}
            //else
            //{
            //    IsHTR2Enable = true;
            //}
            ////ValveAV92.Feedback = SelectedStep.ValveSets[ValveAV92.DeviceName.Trim()] == "Open";
            ////ValveAV93.Feedback = SelectedStep.ValveSets[ValveAV93.DeviceName.Trim()] == "Open";
            ////ValveAV94.Feedback = SelectedStep.ValveSets[ValveAV94.DeviceName.Trim()] == "Open";
            ////ValveAV95.Feedback = SelectedStep.ValveSets[ValveAV95.DeviceName.Trim()] == "Open";
            ////ValveAV96.Feedback = SelectedStep.ValveSets[ValveAV96.DeviceName.Trim()] == "Open";

        }

        //private void BeforeChangedStep()
        //{
        //    List<string> keys = SelectedStep.ValveSets.Keys.ToList();
        //    foreach (var item in keys)
        //    {
        //        var property = this.GetType().GetProperties().Where(x => x.Name == item).FirstOrDefault();
        //        object value = property.GetValue(this, null);
        //        if (value != null)
        //        {
        //            SelectedStep.ValveSets[item] = ((AITValveData)value).VirtualFeedback ? "Open" : "Close";
        //        }
        //    }

        //    List<string> mfcKeys = SelectedStep.MFCSets.Keys.ToList();
        //    foreach (var mfcitem in mfcKeys)
        //    {
        //        var replaceStr = mfcitem.Substring(7).Replace(".Flow", "");
        //        var property = this.GetType().GetProperties().Where(x => x.Name == replaceStr).FirstOrDefault();
        //        if (property == null) continue;
        //        object value = property.GetValue(this, null);
        //        if (value != null)
        //        {
        //            SelectedStep.MFCSets[mfcitem].Set = ((AnalogDeviceDataItem)value).FeedBack.ToString();
        //        }
        //    }
        //}


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

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

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            if (CurrentRecipe == null)
            {
                MFCChangedUpdate();
            }
        }

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

        public void TempSetSave()
        {
            foreach (var item in SelectedStep.ValveSets)
            {
                switch (item.Name)
                {
                    case "AGV":
                        item.Value = AGVPump.VirtualFeedback;
                        break;
                    case "MBP":
                        item.Value = BothPump.VirtualFeedback;
                        break;
                    case "DP":
                        item.Value = AUCPump.VirtualFeedback;
                        break;
                    case "BWR":
                        item.Value = ValveBWR.VirtualFeedback;
                        break;
                    case "DPR":
                        item.Value = ValveAV91.VirtualFeedback;
                        break;
                    case "F2Cln":
                        item.Value = IsF2ClnOn;
                        break;
                    case "HFCln":
                        item.Value = IsHFClnOn;
                        break;
                    case "HTR1":
                        item.Value = IsHTR1Enable;
                        break;
                    case "HTR2":
                        item.Value = IsHTR2Enable;
                        break;
                    default:
                        break;
                }
            }

            //List<string> mfcKeys = SelectedStep.MFCSets.Keys.ToList();
            //foreach (var mfcitem in mfcKeys)
            //{
            //    var replaceStr = mfcitem.Substring(7).Replace(".Flow", "");
            //    var property = this.GetType().GetProperties().Where(x => x.Name == replaceStr).FirstOrDefault();
            //    if (property == null) continue;
            //    object value = property.GetValue(this, null);
            //    if (value != null)
            //    {
            //        SelectedStep.MFCSets[mfcitem].SetValueParam.Value = ((AnalogDeviceDataItem)value).VirtualFeedBack.ToString();
            //    }
            //}
            ((Window)GetView()).DialogResult = true;
        }

        public void SwichValue(string name)
        {
            var dialog = new SwitchValueDialog { };
            dialog.IsOpen = true;
            switch (name.ToUpper())
            {
                case "BWR":
                    dialog.IsOpen = ValveBWR.VirtualFeedback;
                    break;
                case "DPR":
                    dialog.IsOpen = ValveDPR.VirtualFeedback;
                    break;
                case "F2":
                    dialog.IsOpen = IsF2ClnOn;
                    break;
                case "HF":
                    dialog.IsOpen = IsHFClnOn;
                    break;
            }

            dialog.Owner = WinOwner;
            dialog.Topmost = true;
            dialog.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            dialog.DeviceName = $"Swich {name}";

            dialog.ShowDialog();

            if ((bool)dialog.IsSave)
            {
                switch (name.ToUpper())
                {
                    case "BWR":
                        InvokeClient.Instance.Service.DoOperation($"{ValveBWR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", dialog.IsOpen);
                        break;
                    case "DPR":
                        InvokeClient.Instance.Service.DoOperation($"{ValveDPR.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", dialog.IsOpen);
                        break;
                    case "F2":
                        IsF2ClnOn = dialog.IsOpen;
                        SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "F2Cln").Value = IsF2ClnOn;
                        //InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", dialog.IsOpen);
                        break;
                    case "HF":
                        IsHFClnOn = dialog.IsOpen;
                        SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HFCln").Value = IsHFClnOn;
                        // InvokeClient.Instance.Service.DoOperation($"PM1.SetHFClnEnable", dialog.IsOpen);
                        break;
                }
            }
        }

        public void SetEnable(string name)
        {

            switch (name.ToUpper())
            {
                case "HTR1":
                    IsHTR1Enable = !IsHTR1Enable;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HTR1").Value = IsHTR1Enable;
                    //InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR1Enable", dialog.IsOpen);
                    break;
                case "HTR2":
                    IsHTR2Enable = !IsHTR2Enable;
                    SelectedStep.ValveSets.FirstOrDefault(x => x.Name == "HTR2").Value = IsHTR2Enable;
                    // InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", dialog.IsOpen);
                    break;
            }


        }

        public void SelectPump(string _pumpname)
        {
            if (!DialogBox.Confirm($"Are you sure change {_pumpname} status?"))
                return;

            if (_pumpname == "AUC")
            {
                InvokeClient.Instance.Service.DoOperation($"{AUCPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", !AUCPump.VirtualFeedback);
            }
            if (_pumpname == "AGV")
            {
                InvokeClient.Instance.Service.DoOperation($"{AGVPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", !AGVPump.VirtualFeedback);
            }
            if (_pumpname == "Both")
            {
                InvokeClient.Instance.Service.DoOperation($"{BothPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", !BothPump.VirtualFeedback);
            }
            if (_pumpname == "DP")
            {
                InvokeClient.Instance.Service.DoOperation($"{BothPump.UniqueName}.{AITValveOperation.GVVirtualTurnValve}", !BothPump.VirtualFeedback);
            }
        }


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

    }



}