using Aitex.Core.Common.DeviceData;
using Aitex.Core.Util;
using Caliburn.Micro;
using Caliburn.Micro.Core;
using DocumentFormat.OpenXml.Bibliography;
using DocumentFormat.OpenXml.Office2010.Excel;
using FurnaceUI.Client.Dialog;
using FurnaceUI.Common;
using FurnaceUI.Models;
using FurnaceUI.Views.Editors;
using FurnaceUI.Views.Parameter;
using FurnaceUI.Views.ParameterSC;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Utilities;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using MECF.Framework.UI.Client.CenterViews.Parameter;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using RecipeEditorLib.RecipeModel.Params;
using SciChart.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace FurnaceUI.Views.Recipes
{
    public class RecipeProcessReadOnlyViewModel : FurnaceUIViewModelBase
    {
        public string DefaultUnit { get; set; }

        public string _defaultUnit
        {
            get { return DefaultUnit + "/S"; }
        }


        #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; }
        [Subscription("PM1.MFM57.DeviceData")]
        public AITWaterFlowMeterData MFM57Flow { get; set; }
        #endregion

        [Subscription("PM1.EditRecipeStepNo")]
        public int EditRecipeStepNo { get; set; }
        [Subscription("PM1.EditRecipeName")]
        public string EditRecipeName { get; set; }

        [Subscription("PM1.EditRecipeStepName")]
        public string EditRecipeStepName { get; set; }

        private UIElement _parent;

        public void SetParent(UIElement parent)
        {
            _parent = parent;
        }

        private readonly RecipeProvider _recipeProvider = new RecipeProvider();

        private Dictionary<string, ObservableCollection<RecipeTemplateColumnBase>> RecipeTemplate;

        private Dictionary<string, string> TemperatureValues { get; set; } = new Dictionary<string, string>();
        public ObservableCollection<TempSetData> HeadLst { get; set; } = new ObservableCollection<TempSetData>();

        private RecipeDataBase _CurrentRecipe = new RecipeDataBase();

        public RecipeDataBase CurrentRecipe
        {
            get { return _CurrentRecipe; }
            set { _CurrentRecipe = value; this.NotifyOfPropertyChange(nameof(CurrentRecipe)); }
        }

        private bool _isStandbyChecked;
        public bool IsStandbyChecked
        {
            get => _isStandbyChecked;
            set
            {
                _isStandbyChecked = value;
                NotifyOfPropertyChange(nameof(IsStandbyChecked));
            }
        }

        private bool _isStandbyCheckedHide;
        public bool IsStandbyCheckedHide
        {
            get => _isStandbyCheckedHide;
            set
            {
                _isStandbyCheckedHide = value;
                NotifyOfPropertyChange(nameof(IsStandbyCheckedHide));
            }
        }

        private bool _isStandbyCheckedSelect = false;

        private bool _isStandbyEnabled;
        public bool IsStandbyEnabled
        {
            get => _isStandbyEnabled;
            set
            {
                _isStandbyEnabled = value;
                NotifyOfPropertyChange(nameof(IsStandbyEnabled));
            }
        }

        private bool _isCommandConditionEventEnabled;
        public bool IsCommandConditionEventEnabled
        {
            get => _isCommandConditionEventEnabled;
            set
            {
                _isCommandConditionEventEnabled = value;
                NotifyOfPropertyChange(nameof(IsCommandConditionEventEnabled));
            }
        }
        private string _selectBtnName;

        public string SelectBtnName
        {
            get { return _selectBtnName; }
            set { _selectBtnName = value; this.NotifyOfPropertyChange(nameof(SelectBtnName)); }
        }
        private Step _selectedRecipeStep = null;

        public Step SelectedRecipeStep
        {
            get => _selectedRecipeStep;
            set
            {
                _selectedRecipeStep = value;
                NotifyOfPropertyChange(nameof(SelectedRecipeStep));
            }
        }

        private int _IndexNoDefault = 0;
        public int IndexNoDefault
        {
            get { return _IndexNoDefault; }
            set
            {
                _IndexNoDefault = value;
                NotifyOfPropertyChange(nameof(IndexNoDefault));
            }
        }
        private bool _appendStepItemIsEnabled;

        public bool AppendStepItemIsEnabled
        {
            get => _appendStepItemIsEnabled;
            set
            {
                _appendStepItemIsEnabled = value;
                NotifyOfPropertyChange(nameof(AppendStepItemIsEnabled));
            }
        }

        private bool _overWriteCopyIsEnabled;

        public bool OverWriteCopyIsEnabled
        {
            get => _overWriteCopyIsEnabled;
            set
            {
                _overWriteCopyIsEnabled = value;
                NotifyOfPropertyChange(nameof(OverWriteCopyIsEnabled));
            }
        }

        private bool _insertCopyIsEnabled;

        public bool InsertCopyIsEnabled
        {
            get => _insertCopyIsEnabled;
            set
            {
                _insertCopyIsEnabled = value;
                NotifyOfPropertyChange(nameof(InsertCopyIsEnabled));
            }
        }

        private bool _prevStepOverwriteIsEnabled;

        public bool PrevStepOverwriteIsEnabled
        {
            get => _prevStepOverwriteIsEnabled;
            set
            {
                _prevStepOverwriteIsEnabled = value;
                NotifyOfPropertyChange(nameof(PrevStepOverwriteIsEnabled));
            }
        }

        private bool _prevStepInsertIsEnabled;

        public bool PrevStepInsertIsEnabled
        {
            get => _prevStepInsertIsEnabled;
            set
            {
                _prevStepInsertIsEnabled = value;
                NotifyOfPropertyChange(nameof(PrevStepInsertIsEnabled));
            }
        }

        private bool _prevStepItemIsEnabled;

        public bool PrevStepItemIsEnabled
        {
            get => _prevStepItemIsEnabled;
            set
            {
                _prevStepItemIsEnabled = value;
                NotifyOfPropertyChange(nameof(PrevStepItemIsEnabled));
            }
        }

        private bool _currStepDeleteIsEnabled;

        public bool CurrStepDeleteIsEnabled
        {
            get => _currStepDeleteIsEnabled;
            set
            {
                _currStepDeleteIsEnabled = value;
                NotifyOfPropertyChange(nameof(CurrStepDeleteIsEnabled));
            }
        }

        private bool _multStepsDeleteIsEnabled;

        public bool MultStepsDeleteIsEnabled
        {
            get => _multStepsDeleteIsEnabled;
            set
            {
                _multStepsDeleteIsEnabled = value;
                NotifyOfPropertyChange(nameof(MultStepsDeleteIsEnabled));
            }
        }
        private bool _settingButtonEnable = true;
        public bool SettingButtonEnable
        {
            get => _settingButtonEnable;
            set
            {
                _settingButtonEnable = value;
                NotifyOfPropertyChange(nameof(SettingButtonEnable));
            }
        }

        private string _eventSetting;

        public string EventSetting
        {
            get => _eventSetting;
            set
            {
                _eventSetting = value;
                NotifyOfPropertyChange(nameof(EventSetting));
            }
        }
        public bool IsEnable => CGlobal.RecipeProcessEditViewEnable;//是否是View模式

        RecipeTempSetViewModel recipeTempSetViewModel = null;


        #region"Loader Set Value"
        private Visibility _loaderSet3SpeedVisibility = Visibility.Hidden;

        public Visibility LoaderSet3SpeedVisibility
        {
            get => _loaderSet3SpeedVisibility;
            set
            {
                _loaderSet3SpeedVisibility = value;
                NotifyOfPropertyChange(nameof(LoaderSet3SpeedVisibility));
            }
        }

        private Visibility _loaderSetSpeedVisibility = Visibility.Hidden;

        public Visibility LoaderSetSpeedVisibility
        {
            get => _loaderSetSpeedVisibility;
            set
            {
                _loaderSetSpeedVisibility = value;
                NotifyOfPropertyChange(nameof(LoaderSetSpeedVisibility));
            }
        }

        private Visibility _loaderSetSpeedFloatVisibility = Visibility.Hidden;

        public Visibility LoaderSetSpeedFloatVisibility
        {
            get => _loaderSetSpeedFloatVisibility;
            set
            {
                _loaderSetSpeedFloatVisibility = value;
                NotifyOfPropertyChange(nameof(LoaderSetSpeedFloatVisibility));
            }
        }

        public bool CommandBtnVisibility
        {
            get
            {
                return GetCommandBtnVisibility();
            }
            set { }
        }

        public bool CommandBtnHeight
        {
            get
            {
                return !CommandBtnVisibility;
            }
            set { }
        }

        public bool IsViewRecipeHistory = false;

        public ShowRecipeHistory RecipeHistory { get; set; }

        private TimeDict TimeDict;
        private APCSettingDict APCSettings;
        private FlowSettingDict FlowSettings;

        private bool GetCommandBtnVisibility()
        {
            List<string> noNeedEndRecipeType = new List<string>() {
            "reset"
            };
            var isContainsType = noNeedEndRecipeType.Contains(CurrentRecipe.PrefixPath.Split('\\').LastOrDefault());
            if (null == CurrentRecipe || string.IsNullOrEmpty(CurrentRecipe.PrefixPath) || isContainsType)
            {
                return false;
            }
            return true;

        }
        public void SetShowLoaderValuePanel(string selectedCmd)
        {
            switch (selectedCmd)
            {
                case "Boat Load":
                case "Boat Unload":
                    LoaderSet3SpeedVisibility = Visibility.Visible;
                    LoaderSetSpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedFloatVisibility = Visibility.Hidden;
                    break;
                case "Boat Rotate":
                    LoaderSet3SpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedFloatVisibility = Visibility.Visible;
                    break;
                case "Boat CAP2":
                    LoaderSet3SpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedVisibility = Visibility.Visible;
                    LoaderSetSpeedFloatVisibility = Visibility.Hidden;
                    break;
                case "Stop(Include R-axis)":
                case "Boat Rotate Stop":
                case "Boat Loader Home":
                case "None":
                case "NONE":
                    LoaderSet3SpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedVisibility = Visibility.Hidden;
                    LoaderSetSpeedFloatVisibility = Visibility.Hidden;
                    break;
                default:
                    break;
            }
        }

        //public void SetLoaderValue(string selectedCmd, string Values)
        //{
        //    switch (selectedCmd)
        //    {
        //        case "Boat Load":
        //        case "Boat Unload":
        //            if (string.IsNullOrEmpty(Values)) return;
        //            string[] list = Values.Split(';');
        //            if (list.Length < 3) return;
        //            Loader3Speed1 = int.Parse(list[0]);
        //            Loader3Speed2 = int.Parse(list[1]);
        //            Loader3Speed3 = int.Parse(list[2]);
        //            break;
        //        case "Boat Rotate":
        //            if (string.IsNullOrEmpty(Values)) return;
        //            LoaderFloatRPM = double.Parse(Values);
        //            break;
        //        case "Boat CAP2":
        //            if (string.IsNullOrEmpty(Values)) return;
        //            LoaderSpeed = int.Parse(Values);
        //            break;
        //        case "Stop(Include R-axis)":
        //        case "Boat Rotate Stop":
        //        case "Boat Loader Home":
        //        case "None":
        //            break;
        //        default:
        //            break;
        //    }
        //}

        //public string GetSaveLoaderValue(string selectedCmd)
        //{
        //    switch (selectedCmd)
        //    {
        //        case "Boat Load":
        //        case "Boat Unload":
        //            return $"{Loader3Speed1};{Loader3Speed2};{Loader3Speed3}";
        //        case "Boat Rotate":
        //            return LoaderFloatRPM.ToString();
        //        case "Boat CAP2":
        //            return LoaderSpeed.ToString();
        //        case "Stop(Include R-axis)":
        //        case "Boat Rotate Stop":
        //        case "Boat Loader Home":
        //        case "None":
        //            return "";
        //        default:
        //            return "";
        //    }
        //}

        private void ClearLoaderSetValue()
        {
            if (SelectedRecipeStep != null)
            {
                SelectedRecipeStep.LoaderSpeed1 = 0;
                SelectedRecipeStep.LoaderSpeed2 = 0;
                SelectedRecipeStep.LoaderSpeed3 = 0;
                SelectedRecipeStep.LoaderRPM = 0;
            }
        }
        #endregion

        #region"PressVisibility"

        private Visibility _pressVisibility = Visibility.Hidden;

        public Visibility PressVisibility
        {
            get => _pressVisibility;
            set
            {
                _pressVisibility = value;
                NotifyOfPropertyChange(nameof(PressVisibility));
            }
        }


        private Visibility _pressSlowVacVisibility = Visibility.Hidden;

        public Visibility PressSlowVacVisibility
        {
            get => _pressSlowVacVisibility;
            set
            {
                _pressSlowVacVisibility = value;
                NotifyOfPropertyChange(nameof(PressSlowVacVisibility));
            }
        }

        private Visibility _pressValveAngleVisibility = Visibility.Hidden;

        public Visibility PressValveAngleVisibility
        {
            get => _pressValveAngleVisibility;
            set
            {
                _pressValveAngleVisibility = value;
                NotifyOfPropertyChange(nameof(PressValveAngleVisibility));
            }
        }


        private Visibility _pressWaitVisibility = Visibility.Hidden;

        public Visibility PressWaitVisibility
        {
            get => _pressWaitVisibility;
            set
            {
                _pressWaitVisibility = value;
                NotifyOfPropertyChange(nameof(PressWaitVisibility));
            }
        }


        public void SetShowPressPanel(string selectedCmd)
        {
            if (!"Valve Angle".Equals(selectedCmd))
            {
                SelectedRecipeStep.PressValveAngleSet = "0";
            }
            switch (selectedCmd)
            {
                case "Press":
                case "Press2":
                case "Valve Angle":
                    PressWaitBtnIsEnabled = true;
                    break;
                default:
                    PressWaitBtnIsEnabled = false;
                    break;
            }


            PressWaitIsEnabled = false;
            switch (selectedCmd)
            {
                case "None":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Press":
                case "Press2":
                    PressVisibility = Visibility.Visible;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Slow Vac":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Visible;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Valve Angle":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Visible;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "Full Open":
                case "Full Close":
                case "Hold":
                case "Zero Set":
                case "Cancel Zero":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Hidden;
                    break;
                case "WaitPressUp1":
                case "WaitPressDown1":
                case "WaitPressUp2":
                case "WaitPressDown2":
                    PressVisibility = Visibility.Hidden;
                    PressSlowVacVisibility = Visibility.Hidden;
                    PressValveAngleVisibility = Visibility.Hidden;
                    PressWaitVisibility = Visibility.Visible;
                    PressWaitIsEnabled = true;
                    break;
                default:
                    break;
            }
        }
        //public void SetPressValue(string selectedCmd, string Values)
        //{
        //    if (string.IsNullOrEmpty(Values))
        //    {
        //        if (selectedCmd == "None")
        //        {
        //            PressPID = "";
        //            PressSet = 0f;
        //            PressSlowVacSet = 0f;
        //            PressValveAngleSet = 0f;
        //            LowPressWait = "";
        //            PressWait = 0f;
        //        }
        //        return;
        //    }
        //    string[] list = Values.Split(';');
        //    if (list.Length < 4) return;
        //    switch (selectedCmd)
        //    {
        //        case "None":
        //            PressPID = "";
        //            PressSet = 0f;
        //            break;
        //        case "Press":
        //        case "Press2":
        //            PressPID = list[0];
        //            double.TryParse(list[1], out double pressSet);
        //            PressSet = pressSet;
        //            break;
        //        case "Slow Vac":
        //            double.TryParse(list[1], out double pressSlowVacSet);
        //            PressSlowVacSet = pressSlowVacSet;
        //            break;
        //        case "Valve Angle":
        //            double.TryParse(list[1], out double pressValveAngleSet);
        //            PressValveAngleSet = pressValveAngleSet;
        //            LowPressWait = list[2];
        //            break;
        //        case "Full Open":
        //        case "Full Close":
        //        case "Hold":
        //        case "Zero Set":
        //        case "Cancel Zero":
        //            break;
        //        case "WaitPressUp1":
        //        case "WaitPressDown1":
        //        case "WaitPressUp2":
        //        case "WaitPressDown2":
        //            double.TryParse(list[1], out double presswait);
        //            PressWait = presswait;
        //            break;
        //        default:
        //            break;
        //    }
        //}

        //public string GetSavePressValue(string selectedCmd)
        //{
        //    string[] pressStringList = new string[4] { "", "", "", "" };
        //    pressStringList[0] = PressPID;
        //    switch (selectedCmd)
        //    {
        //        case "Press":
        //        case "Press2":
        //            pressStringList[1] = PressSet.ToString();
        //            break;
        //        case "Slow Vac":
        //            pressStringList[1] = PressSlowVacSet.ToString();
        //            break;
        //        case "Valve Angle":
        //            pressStringList[1] = PressValveAngleSet.ToString();
        //            pressStringList[2] = LowPressWait;
        //            break;
        //        case "Full Open":
        //        case "Full Close":
        //        case "Hold":
        //        case "Zero Set":
        //        case "Cancel Zero":
        //            pressStringList[0] = "";
        //            pressStringList[1] = "";
        //            pressStringList[2] = "";
        //            pressStringList[3] = "";
        //            break;
        //        case "WaitPressUp1":
        //        case "WaitPressDown1":
        //        case "WaitPressUp2":
        //        case "WaitPressDown2":
        //            pressStringList[1] = PressWait.ToString();
        //            break;
        //        default:
        //            pressStringList[0] = "";
        //            pressStringList[1] = "";
        //            pressStringList[2] = "";
        //            pressStringList[3] = "";
        //            break;
        //    }
        //    return string.Join(";", pressStringList);
        //}


        //private string _pressPID;

        //public string PressPID
        //{
        //    get => _pressPID;
        //    set
        //    {
        //        _pressPID = value;
        //        NotifyOfPropertyChange(nameof(PressPID));
        //    }
        //}

        //private double _pressSet;

        //public double PressSet
        //{
        //    get => _pressSet;
        //    set
        //    {
        //        _pressSet = value;
        //        NotifyOfPropertyChange(nameof(PressSet));
        //    }
        //}

        //private double _pressSlowVacSet;

        //public double PressSlowVacSet
        //{
        //    get => _pressSlowVacSet;
        //    set
        //    {
        //        _pressSlowVacSet = value;
        //        NotifyOfPropertyChange(nameof(PressSlowVacSet));
        //    }
        //}

        //private double _pressValveAngleSet;

        //public double PressValveAngleSet
        //{
        //    get => _pressValveAngleSet;
        //    set
        //    {
        //        _pressValveAngleSet = value;
        //        NotifyOfPropertyChange(nameof(PressValveAngleSet));
        //    }
        //}

        //private string _lowPressWait;

        //public string LowPressWait
        //{
        //    get => _lowPressWait;
        //    set
        //    {
        //        _lowPressWait = value;
        //        NotifyOfPropertyChange(nameof(LowPressWait));
        //    }
        //}

        //private double _pressWait;

        //public double PressWait
        //{
        //    get => _pressWait;
        //    set
        //    {
        //        _pressWait = value;
        //        NotifyOfPropertyChange(nameof(PressWait));
        //    }
        //}

        //private void ClearPressSetValue()
        //{
        //    if (SelectedRecipeStep != null)
        //    {
        //        SelectedRecipeStep.PressPID = "None";
        //        SelectedRecipeStep.PressSet = 0;
        //        SelectedRecipeStep.PressSlowVacSet = 0;
        //        SelectedRecipeStep.PressValveAngleSet = "0";
        //        SelectedRecipeStep.PressLowWait = "None";
        //        SelectedRecipeStep.PressWait = 0;
        //    }
        //}

        #endregion

        #region AlarmRecipe Visibility
        public bool IsAlarmReicpe => RecipeType.ToLower() == "alarm";
        public bool IsAbortReicpe => RecipeType.ToLower() == "abort";
        public bool IsSubReicpe => RecipeType.ToLower() == "sub";
        public bool IsTableVisibility => IsAlarmReicpe || IsAbortReicpe || IsSubReicpe;
        public bool IsRecipeHeaderVisibility => !IsTableVisibility;
        public bool IsVPDataListVisibility => !IsTableVisibility;
        public bool IsCombinationVisibility => !IsTableVisibility;
        #endregion

        private bool _pressWaitIsEnabled = false;
        public bool PressWaitIsEnabled
        {
            get => _pressWaitIsEnabled;
            set
            {
                _pressWaitIsEnabled = value;
                NotifyOfPropertyChange(nameof(PressWaitIsEnabled));
            }
        }

        private bool _pressWaitBtnIsEnabled = false;
        public bool PressWaitBtnIsEnabled
        {
            get => _pressWaitBtnIsEnabled;
            set
            {
                _pressWaitBtnIsEnabled = value;
                NotifyOfPropertyChange(nameof(PressWaitBtnIsEnabled));
            }
        }

        private void RefreshUpdate()
        {
            SetChangedStepRefreshUpdate();
            SetCmdIsEnabled();
        }

        private bool _noStandbyIsEnabled = false;
        public bool NoStandbyIsEnabled
        {
            get => _noStandbyIsEnabled;
            set
            {
                _noStandbyIsEnabled = value;
                NotifyOfPropertyChange(nameof(NoStandbyIsEnabled));
            }
        }

        private Visibility _standbyIsVisibility = Visibility.Visible;

        public Visibility StandbyIsVisibility
        {
            get => _standbyIsVisibility;
            set
            {
                _standbyIsVisibility = value;
                NotifyOfPropertyChange(nameof(StandbyIsVisibility));
            }
        }

        private void SetChangedStepRefreshUpdate()
        {
            if (CurrentRecipe.Steps == null || CurrentRecipe.Steps.Count < 1)
            {
                return;
            }
            if (SelectedRecipeStep.Name == "Standby")
            {
                NoStandbyIsEnabled = false;
                StandbyIsVisibility = Visibility.Visible;
                // LoaderSetSpeedFloatVisibility= Visibility.Hidden;
                // LoaderSet3SpeedVisibility= Visibility.Visible;
                // LoaderSetSpeedVisibility = Visibility.Hidden;
            }
            else
            {
                NoStandbyIsEnabled = true && SettingButtonEnable;
                StandbyIsVisibility = Visibility.Visible;
            }
        }

        private void SetCmdIsEnabled()
        {
            AppendStepItemIsEnabled = true;
            if (CurrentRecipe.Steps == null || CurrentRecipe.Steps.Count == 0 || SelectedRecipeStep.Name == "Standby")
            {
                AppendStepItemIsEnabled = true;
                OverWriteCopyIsEnabled = false;
                InsertCopyIsEnabled = false;
                PrevStepOverwriteIsEnabled = false;
                PrevStepInsertIsEnabled = false;
                PrevStepItemIsEnabled = false;
                CurrStepDeleteIsEnabled = false;
                MultStepsDeleteIsEnabled = false;
            }
            else
            {
                if (CurrentRecipe.RecipeChamberType == RecipeDataBase.ProcessType)
                    if (CurrentRecipe.Steps[1].StepNo == SelectedRecipeStep.StepNo)
                    {
                        AppendStepItemIsEnabled = true;
                        OverWriteCopyIsEnabled = false;
                        InsertCopyIsEnabled = true;
                        PrevStepOverwriteIsEnabled = false;
                        PrevStepInsertIsEnabled = false;
                        PrevStepItemIsEnabled = false;
                        CurrStepDeleteIsEnabled = true;
                        MultStepsDeleteIsEnabled = true;
                    }
                    else
                    {
                        OverWriteCopyIsEnabled = true;
                        InsertCopyIsEnabled = true;
                        PrevStepOverwriteIsEnabled = true;
                        PrevStepInsertIsEnabled = true;
                        PrevStepItemIsEnabled = false;
                        CurrStepDeleteIsEnabled = true;
                        MultStepsDeleteIsEnabled = true;
                    }
                else
                {
                    if (CurrentRecipe.Steps[0].StepNo == SelectedRecipeStep.StepNo)
                    {
                        AppendStepItemIsEnabled = true;
                        OverWriteCopyIsEnabled = true;
                        InsertCopyIsEnabled = true;
                        PrevStepOverwriteIsEnabled = false;
                        PrevStepInsertIsEnabled = false;
                        PrevStepItemIsEnabled = false;
                        CurrStepDeleteIsEnabled = true;
                        MultStepsDeleteIsEnabled = true;
                    }
                    else
                    {
                        OverWriteCopyIsEnabled = true;
                        InsertCopyIsEnabled = true;
                        PrevStepOverwriteIsEnabled = true;
                        PrevStepInsertIsEnabled = true;
                        PrevStepItemIsEnabled = false;
                        CurrStepDeleteIsEnabled = true;
                        MultStepsDeleteIsEnabled = true;
                    }
                }
            }
            IsCommandConditionEventEnabled = SettingButtonEnable;
            IsStandbyEnabled = SettingButtonEnable && (RecipeType.ToLower() == "process");
        }

        private string _selectedGasSetting2;
        public string SelectedGasSetting2
        {
            get
            {
                return _selectedGasSetting2;
            }
            set
            {
                _selectedGasSetting2 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting2));
            }
        }
        private string _selectedGasSetting3;
        public string SelectedGasSetting3
        {
            get
            {
                return _selectedGasSetting3;
            }
            set
            {
                _selectedGasSetting3 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting3));
            }
        }
        private string _selectedGasSetting4;
        public string SelectedGasSetting4
        {
            get
            {
                return _selectedGasSetting4;
            }
            set
            {
                _selectedGasSetting4 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting4));
            }
        }
        private string _selectedGasSetting5;
        public string SelectedGasSetting5
        {
            get
            {
                return _selectedGasSetting5;
            }
            set
            {
                _selectedGasSetting5 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting5));
            }
        }
        private string _selectedGasSetting6;
        public string SelectedGasSetting6
        {
            get
            {
                return _selectedGasSetting6;
            }
            set
            {
                _selectedGasSetting6 = value;
                NotifyOfPropertyChange(nameof(SelectedGasSetting6));
            }
        }

        private List<ConfigNode> _ConfigNodes = new List<ConfigNode>();
        public List<ConfigNode> ConfigNodes
        {
            get { return _ConfigNodes; }
            set
            {
                _ConfigNodes = value;
                NotifyOfPropertyChange(nameof(ConfigNodes));
            }
        }
        private ObservableCollection<MFCData> _mFCDatas = new ObservableCollection<MFCData>();
        private ObservableCollection<MFCData> _mFCDatas1 = new ObservableCollection<MFCData>();

        public ObservableCollection<TempSetData> TempList { get; set; } = new ObservableCollection<TempSetData>();
        public ObservableCollection<MFCData> MFCDataList
        {
            get => _mFCDatas;
            set
            {
                _mFCDatas = value;
                NotifyOfPropertyChange(nameof(MFCDataList));
            }
        }

        private string _pressureUnit;
        public string PressureUnit
        {
            get => _pressureUnit;
            set
            {
                _pressureUnit = value;
                NotifyOfPropertyChange(nameof(PressureUnit));
            }
        }

        public string RecipeType { get; set; }

        public RecipeProcessReadOnlyViewModel(string strPrefixPath, string strRecipeName, string permission = "")
        {
            PumpDict.Clear();
            PumpDict.Add("DPR", "ValveAV91");
            PumpDict.Add("AGV", "AGVPump");
            PumpDict.Add("MBP", "BothPump");
            PumpDict.Add("DP", "AUCPump");
            PumpDict.Add("BWR", "ValveBWR");
            OtherPumpDict.Clear();
            OtherPumpDict.Add("F2Cln", "F2Cln");
            OtherPumpDict.Add("HFCln", "HFCln");
            OtherPumpDict.Add("HTR1", "HTR1");
            OtherPumpDict.Add("HTR2", "HTR2");
            DefaultUnit = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.APC.PressureUnit");
            RecipeTemplate = _recipeProvider.GetGroupRecipeTemplate();
            CurrentRecipe.PrefixPath = strPrefixPath;
            CurrentRecipe.Name = strRecipeName;
            CurrentRecipe.RecipePermission = permission;
        }

        public RecipeProcessReadOnlyViewModel(ShowRecipeHistory showRecipeHistory)
        {
            IsViewRecipeHistory = true;
            RecipeHistory = showRecipeHistory;
            RecipeTemplate = _recipeProvider.GetGroupRecipeTemplate();
            CurrentRecipe.PrefixPath = showRecipeHistory.Recipe_Type;
            CurrentRecipe.Name = showRecipeHistory.Recipe_Name;
            CurrentRecipe.RecipePermission = showRecipeHistory.Recipe_Premission;
            TimeDict = new TimeDict();
            APCSettings = new APCSettingDict();
            FlowSettings = new FlowSettingDict();
            // InvokeClient.Instance.Service.DoOperation($"SetCurrentRecipeName", strRecipeName);
        }

        protected override void OnViewLoaded(object view)
        {
            
            base.OnViewLoaded(view);
        }

        protected override void OnActivate()
        {
            base.OnActivate();

            InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorRecipeOK", "");
        }


        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
            InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorPROCManualOK", "");
        }


        protected override void OnInitialize()
        {
            base.OnInitialize();
            //  GetHeaderConfig();
            LoadData();
            RefreshUpdate();
        }

        private void LoadData()
        {
            CurrentRecipe.Clear();
            var recipeContent = _recipeProvider.LoadRecipe(CurrentRecipe.PrefixPath, CurrentRecipe.Name);
            if (string.IsNullOrEmpty(recipeContent))
            {
                System.Windows.MessageBox.Show($"{CurrentRecipe.PrefixPath}\\{CurrentRecipe.Name} is empty, please confirm the file is valid.");
                return;
            }
            //     CurrentRecipe.RecipeChamberType = "OriginChamber";
            CurrentRecipe.InitData(CurrentRecipe.PrefixPath, CurrentRecipe.Name, recipeContent, "PM1");
            if (CurrentRecipe.Steps.Count > 0)
            {
                SelectStep(CurrentRecipe.Steps[IndexNoDefault]);
            }
            IsCommandConditionEventEnabled = true;
            PressureUnit = "(" + (string)QueryDataClient.Instance.Service.GetConfig("PM1.APC.PressureUnit") + ")";

        }

        public void SwitchPage(string page)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch (page)
            {
                case "GFCSetting":

                    RecipeGasPanelSettingViewModel recipeGasPanelSettingViewModel = new RecipeGasPanelSettingViewModel
                    {
                        SelectedStepNo = SelectedRecipeStep.StepNo,
                        SelectedStepName = $"{SelectedRecipeStep.StepNo}:{SelectedRecipeStep.Name}",
                        CurrentRecipe = CurrentRecipe,
                        SelectedStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault()
                    };
                    recipeGasPanelSettingViewModel.ChangedStepEvent += RecipeGasPanelSettingViewModel_ChangedStepEvent;
                    (windowManager as WindowManager)?.ShowDialogWithTitle(recipeGasPanelSettingViewModel, null, "Recipe Gas Panel Setting");
                    break;
            }
        }

        private void RecipeGasPanelSettingViewModel_ChangedStepEvent(Step step)
        {
            SelectStep(step);
        }

        private Step OldStep;

        private Dictionary<string, string> PumpDict = new Dictionary<string, string>();
        private Dictionary<string, string> OtherPumpDict = new Dictionary<string, string>();

        public void SelectStep(object step)
        {
            if (step == null || !(step is Step))
            {
                return;
            }
            var step1 = (Step)step;
            var SelectedStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == step1.StepNo).FirstOrDefault();
            if (OldStep != null && step1.StepNo != OldStep.StepNo)
            {

                var selectedOldStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == OldStep.StepNo).FirstOrDefault();
                if (step1 != null && !string.IsNullOrEmpty(step1.TemperatureControlMode))
                {
                    if (step1.TemperatureControlMode.Contains("Profile"))
                    {
                        SelectBtnName = "Profile";
                    }
                    else
                    {
                        SelectBtnName = step1.TemperatureControlMode;
                    }
                }
                else
                {
                    SelectBtnName = "";
                }
                //if (selectedOldStep != null)
                //{
                //    selectedOldStep.LoaderValue = GetSaveLoaderValue(selectedOldStep.LoaderCommand);
                //    selectedOldStep.PressValue = GetSavePressValue(selectedOldStep.PressCommand);
                //}
            }
            OldStep = step1;
            string strName = step1.Name.Trim();
            SelectedRecipeStep = SelectedStep;
            //if (SelectedRecipeStep.Name != EditRecipeStepName || SelectedRecipeStep.StepNo != step1.StepNo)
            //{
            SetShowLoaderValuePanel(SelectedRecipeStep.LoaderCommand);
            SetShowPressPanel(SelectedRecipeStep.PressCommand);
            InvokeClient.Instance.Service.DoOperation($"PM1.SetEditRecipeStepName", SelectedRecipeStep.Name);

            var selectedStep = step1;

            if (selectedStep.MFCSets != null && selectedStep.MFCSets.Count > 0)
            {
                Dictionary<string, string> dictMFC = new Dictionary<string, string>();
                foreach (var key in selectedStep.MFCSets.Keys)
                {
                    dictMFC[key.Replace(".Flow", "")] = $"{selectedStep.MFCSets[key].SetValueParam.Value};{selectedStep.MFCSets[key].Rampng};{selectedStep.MFCSets[key].AlarmValue}";
                }
                InvokeClient.Instance.Service.DoOperation($"PM1.SetAllMfcVirtualValue", dictMFC);
            }
            if (selectedStep.ValveSets != null && selectedStep.ValveSets.Count > 0)
            {
                Dictionary<string, bool> dictValve = new Dictionary<string, bool>();
                foreach (var key in selectedStep.ValveSets.Keys)
                {
                    if (PumpDict.ContainsKey(key))
                    {
                       // dictValve[PumpDict[key]] = selectedStep.ValveSets[key] == "Open" ? true : false;
                    }
                    else if (OtherPumpDict.ContainsKey(key))
                    { }
                    else
                    { 
                    dictValve[key] = selectedStep.ValveSets[key] == "Open" ? true : false;
                    }
                }
                InvokeClient.Instance.Service.DoOperation($"PM1.SetAll{AITValveOperation.GVVirtualTurnValve}", dictValve);
            }
            if (selectedStep.TemperatureSets != null)
            {
                TempList.Clear();
                foreach (var item in selectedStep.TemperatureSets.Values)
                {
                    TempList.Add(item);
                }
            }
            //SetLoaderValue(selectedStep.LoaderCommand, selectedStep.LoaderValue);
            //SetPressValue(selectedStep.PressCommand, selectedStep.PressValue);
            //}
            RefreshUpdate();
        }

        #region"StepEdit"
        public void StepEdit(string stepEditCmd)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch (stepEditCmd)
            {
                case "Append":
                    CurrentRecipe.Steps.Add(CurrentRecipe.CreateStep());
                    int TempSelectIndex = 0;
                    Step step = CurrentRecipe.Steps.FirstOrDefault(x => x.Name == "Standby");
                    for (int i = 0; i < this.CurrentRecipe.Steps.Count; i++)
                    {
                        if (step == null)
                        {
                            this.CurrentRecipe.Steps[i].StepNo = i + 1;
                        }
                        else
                        {
                            this.CurrentRecipe.Steps[i].StepNo = i;
                        }
                        TempSelectIndex = i;
                    }
                    IndexNoDefault = TempSelectIndex;
                    SelectStep(CurrentRecipe.Steps[TempSelectIndex]);
                    break;
                case "InsertCopy":
                    InsertCopyStep();
                    break;
                case "OverWrite"://任何步骤的内容都可以覆盖到选定的步骤中
                    OverWriteStep();
                    break;
                case "PrevStepOverwrite"://用上一步的内容覆盖所选步骤
                    PrevStepOverwriteStep();
                    break;
                case "PrevStepInsert"://在选定步骤之前，插入带有前一步内容的新步骤。
                    InsertPrevStep();
                    break;
                case "PrevStepItem":
                    break;
                case "CurrStepDelete":
                    if (SelectedRecipeStep == null || CurrentRecipe == null)
                    { return; }
                    CurrDeleteStep();
                    break;
                case "MultStepsDelete":
                    RecipeStepDeleteDialogViewModel recipedeleteDialog = new RecipeStepDeleteDialogViewModel(CurrentRecipe);
                    (windowManager as WindowManager)?.ShowDialogWithTitle(recipedeleteDialog, null, "Delete Recipe Step");
                    IndexNoDefault = 0;
                    SelectStep(CurrentRecipe.Steps[0]);
                    break;
                default:
                    break;
            }
        }

        private void OverWriteStep()
        {
            var windowManager = IoC.Get<IWindowManager>();
            if (CurrentRecipe == null) return;
            RecipeStepSelectDialogViewModel recipeStepSelectDialogViewModel = new RecipeStepSelectDialogViewModel(CurrentRecipe);
            if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeStepSelectDialogViewModel, null, "Select Recipe Step"))
            {
                var tempStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                CurrentRecipe.ShallowCopyStep(ref tempStep, recipeStepSelectDialogViewModel.SelectedStep);
                SelectStep(SelectedRecipeStep);
            }
        }

        private void PrevStepOverwriteStep()
        {
            int index = -1;
            index = SelectedRecipeStep.StepNo;
            if (index > 1)
            {
                var setStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                CurrentRecipe.ShallowCopyStep(ref setStep, CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo - 1).FirstOrDefault());
                SelectStep(SelectedRecipeStep);
            }
        }

        public void CurrDeleteStep()
        {
            int index = -1;
            index = SelectedRecipeStep.StepNo;
            CurrentRecipe.Steps.Remove(CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault());
            if (CurrentRecipe.RecipeChamberType != RecipeDataBase.ProcessType)
            {
                for (int i = index; i < this.CurrentRecipe.Steps.Count + 1; i++)
                {
                    this.CurrentRecipe.Steps[i - 1].StepNo = i;
                }

            }
            else
            {
                for (int i = index; i < this.CurrentRecipe.Steps.Count + 1; i++)
                {
                    this.CurrentRecipe.Steps[i - 1].StepNo = i - 1;
                }
            }
            if (index > CurrentRecipe.Steps.Count - 1)
            {
                IndexNoDefault = CurrentRecipe.Steps.Count - 1;
            }
            else
            {
                IndexNoDefault = CurrentRecipe.Steps.IndexOf(CurrentRecipe.Steps.FirstOrDefault(x => x.StepNo == index));
            }
            SelectStep(CurrentRecipe.Steps[IndexNoDefault]);
            RefreshUpdate();
        }

        public void InsertPrevStep()
        {
            var foundPrevStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo - 1).FirstOrDefault();
            var foundStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
            if (foundPrevStep != null && foundStep != null)
            {
                var tempStep = CurrentRecipe.CreateStep();
                CurrentRecipe.CloneStep(ref tempStep, foundPrevStep);
                tempStep.StepNo = foundPrevStep.StepNo + 1;
                foreach (var item in this.CurrentRecipe.Steps)
                {
                    if (item.StepNo >= tempStep.StepNo)
                    {
                        item.StepNo += 1;
                    }
                }
                Step step = CurrentRecipe.Steps.FirstOrDefault(x => x.Name == "Standby");
                if (step == null)
                {
                    this.CurrentRecipe.Steps.Insert(foundPrevStep.StepNo, tempStep);
                }
                else
                {
                    this.CurrentRecipe.Steps.Insert(foundPrevStep.StepNo + 1, tempStep);
                }
                if (step == null)
                {
                    IndexNoDefault = SelectedRecipeStep.StepNo - 1;
                }
                else
                {
                    IndexNoDefault = SelectedRecipeStep.StepNo;
                }
                SelectStep(CurrentRecipe.Steps[IndexNoDefault]);
            }
        }

        public void InsertCopyStep()
        {
            var windowManager = IoC.Get<IWindowManager>();
            if (CurrentRecipe == null) return;
            RecipeStepSelectDialogViewModel recipeStepSelectDialogViewModel = new RecipeStepSelectDialogViewModel(CurrentRecipe);
            if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeStepSelectDialogViewModel, null, "Select Recipe Step"))
            {
                var foundStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                if (foundStep != null)
                {
                    var tempStep = CurrentRecipe.CreateStep();
                    CurrentRecipe.CloneStep(ref tempStep, recipeStepSelectDialogViewModel.SelectedStep);
                    tempStep.StepNo = foundStep.StepNo;
                    int insertIndex = this.CurrentRecipe.Steps.IndexOf(foundStep);
                    this.CurrentRecipe.Steps.Insert(insertIndex, tempStep);
                    if (CurrentRecipe.RecipeChamberType != RecipeDataBase.ProcessType)
                    {
                        for (int i = tempStep.StepNo; i < this.CurrentRecipe.Steps.Count + 1; i++)
                        {
                            this.CurrentRecipe.Steps[i - 1].StepNo = i;
                        }
                    }
                    else
                    {
                        for (int i = tempStep.StepNo; i < this.CurrentRecipe.Steps.Count; i++)
                        {
                            this.CurrentRecipe.Steps[i].StepNo = i;
                        }
                    }
                    SelectStep(CurrentRecipe.Steps[insertIndex]);
                }
            }
        }
        #endregion
        //撤销修改
        public void RecipeIsChangeClick(object cmdName, object value)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch ((string)cmdName)
            {
                case "Alarm":

                    break;
                case "MFC":

                    break;
                case "Gas":

                    break;
                case "AUX":

                    break;
                case "Press":

                    break;
                case "Temp":

                    break;
                default:
                    break;
            }
        }

        public void TempSetClick(object sender)
        {
            string stSetValue = ShowNumberKeyboard(sender as Button, "");
            if (stSetValue != "Cancel")
            {
                foreach (var item in TempList)
                {
                    item.SetValue = stSetValue;
                }
            }
        }

        public void RampSetClick(object sender)
        {
            string strSetRamp = ShowNumberKeyboard(sender as Button, "");
            if (strSetRamp != "Cancel")
            {
                foreach (var item in TempList)
                {
                    item.RampngValue = strSetRamp;
                }
            }
        }

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

            if (string.IsNullOrEmpty(val) || !val.Contains("—"))
            {
                return val;
            }
            var temperatureControlModes = val.Split('—').ToList();

            SelectBtnName = temperatureControlModes.LastOrDefault();
            if (temperatureControlModes.Count == 1)
            {
                SelectBtnName = "";

            }
            return temperatureControlModes.FirstOrDefault();
        }
        public void TempTextClick(string type, object sender)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch (type)
            {
                case "Mode":
                    RecipeTempModeViewModel recipeTempModeViewModel = new RecipeTempModeViewModel();
                    recipeTempModeViewModel.CurrentRecipe = CurrentRecipe;
                    recipeTempModeViewModel.SelectProfileTable = SelectedRecipeStep.TemperatureControlMode;
                    recipeTempModeViewModel.SelectBtnName = SelectBtnName;
                    var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(recipeTempModeViewModel, null, "Temp Mode");
                    if ((bool)rtn)
                    {

                        SelectBtnName = recipeTempModeViewModel.SelectBtnName;
                        SelectedRecipeStep.TemperatureControlMode = recipeTempModeViewModel.ResultString;
                        var foundStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                        if (foundStep != null)
                        {
                            if (null != recipeTempModeViewModel && !string.IsNullOrEmpty(recipeTempModeViewModel.ResultString) && recipeTempModeViewModel.ResultString.Contains("Profile"))
                            {
                                SelectBtnName = "Profile";
                            }
                            foundStep.TemperatureControlMode = recipeTempModeViewModel.ResultString;
                        }
                    }
                    break;
                case "Correct":

                    TempCorrectionEditViewModel tempCorrectionEditViewModel = new TempCorrectionEditViewModel();
                    tempCorrectionEditViewModel.CurrentRecipe = CurrentRecipe;
                    tempCorrectionEditViewModel.ResultString = SelectedRecipeStep.TemperatureCorrect;
                    tempCorrectionEditViewModel.IsEnabledControl = false;
                    tempCorrectionEditViewModel.AutoSelectVisibility = Visibility.Visible;
                    //  tempOffsetTableViewModel.SelectedRecipeStep = SelectedRecipeStep;
                    rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(tempCorrectionEditViewModel, null, "Temp Correct Table");
                    if ((bool)rtn)
                    {
                        SelectedRecipeStep.TemperatureCorrect = tempCorrectionEditViewModel.ResultString;
                        var foundStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                        if (foundStep != null)
                        {
                            foundStep.TemperatureCorrect = tempCorrectionEditViewModel.ResultString;
                        }
                    }
                    break;
                case "PID":
                    TempOffsetTableViewModel tempOffsetTableViewModel1 = new TempOffsetTableViewModel();
                    tempOffsetTableViewModel1.TempOffsetTableSelected = SelectedRecipeStep.TemperaturePID;
                    tempOffsetTableViewModel1.CurrentRecipe = CurrentRecipe;
                    tempOffsetTableViewModel1.IsEnabledControl = false;
                    tempOffsetTableViewModel1.SelectedRecipeStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(tempOffsetTableViewModel1, null, "Temp PID Table");
                    if ((bool)rtn)
                    {
                        SelectedRecipeStep.TemperaturePID = tempOffsetTableViewModel1.TempOffsetTableSelected;
                        var foundStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                        if (foundStep != null)
                        {
                            foundStep.TemperaturePID = tempOffsetTableViewModel1.TempOffsetTableSelected;
                        }
                    }
                    break;
                default:
                    break;
            }

        }

        public void TempTextChanged(string type, object sender, object item)
        {
            if (!string.IsNullOrEmpty(type) && item != null && sender != null)
            {
                TempSetData tempData = (TempSetData)item;
                string value = ((TextBox)sender).Text;
                int stepNo = SelectedRecipeStep.StepNo;
                var step = CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault();
                if (step != null)
                {
                    var tempValue = CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault().TemperatureSets.Values.Where(x => x.Name == tempData.Name).FirstOrDefault();
                    if (tempValue == null) return;
                    switch (type)
                    {
                        case "Value":
                            tempValue.SetValue = value;
                            break;
                        case "Ramp":
                            tempValue.RampngValue = value;
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        public void StepEdit(object cmdName, object value)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch ((string)cmdName)
            {
                case "StepName":
                    RecipeStepNameViewModel recipeStepNameViewModel = new RecipeStepNameViewModel() { SelectedStepName = SelectedRecipeStep.Name };
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeStepNameViewModel, null, "Recipe Step Name"))
                    {
                        SelectedRecipeStep.Name = recipeStepNameViewModel.SelectedStepName;
                    }
                    break;
                case "StepTime":
                    RecipeStepTimeViewModel recipeStepTimeViewModel = new RecipeStepTimeViewModel("StepTime");
                    if (CurrentRecipe.Steps.Count > 0)
                    {
                        var timeValue = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().Time;
                        recipeStepTimeViewModel.SelectTime = (timeValue == null || timeValue.Contains(':')) ? "Value" : timeValue;
                        if (recipeStepTimeViewModel.SelectTime == "Value")
                        {
                            recipeStepTimeViewModel.SelectValueTime = timeValue;
                        }
                        (windowManager as WindowManager)?.ShowDialogWithTitle(recipeStepTimeViewModel, null, "Step Time Set");
                        if (recipeStepTimeViewModel.IsSave)
                        {
                            CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().Time = recipeStepTimeViewModel.SelectTime;

                            if (recipeStepTimeViewModel.SelectTime == "Value")
                            {
                                SelectedRecipeStep.Time = recipeStepTimeViewModel.SelectTime + ":" + recipeStepTimeViewModel.SelectValueTime;
                                if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault() != null)
                                {
                                    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().Time = recipeStepTimeViewModel.SelectValueTime;
                                }
                            }
                            else
                            {
                                SelectedRecipeStep.Time = recipeStepTimeViewModel.SelectTime + ":" + recipeStepTimeViewModel.RecipeStepTime[recipeStepTimeViewModel.SelectTime];
                            }
                        }
                    }
                    break;
                case "RecipeCommand":
                    RecipeCommandViewModel recipeCommandViewModel = new RecipeCommandViewModel();
                    ObservableCollection<ShowStep> loopStepNames = new ObservableCollection<ShowStep>(CurrentRecipe.Steps.OrderBy(x => x.StepNo).Where(x => x.StepNo < SelectedRecipeStep.StepNo && x.Name != "Standby").Select(x => new ShowStep() { StepNo = x.StepNo, StepName = x.Name }).ToList());
                    ObservableCollection<ShowStep> jumpStepNames = new ObservableCollection<ShowStep>(CurrentRecipe.Steps.OrderBy(x => x.StepNo).Where(x => x.StepNo != SelectedRecipeStep.StepNo).Select(x => new ShowStep() { StepNo = x.StepNo, StepName = x.Name }).ToList());
                    recipeCommandViewModel.LoopStepNames = loopStepNames;
                    recipeCommandViewModel.JumpStepNames = jumpStepNames;
                    recipeCommandViewModel.SelectedRecipeStep = SelectedRecipeStep;
                    recipeCommandViewModel.SelectRecipeCommand = SelectedRecipeStep.Command;
                    recipeCommandViewModel.RecipeData = CurrentRecipe;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeCommandViewModel, null, "Recipe Command"))
                    {
                        SelectedRecipeStep.Command = recipeCommandViewModel.SelectRecipeCommand;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().Command = SelectedRecipeStep.Command;
                    }
                    break;
                case "ConditionCheck":
                    RecipeConditionCheckSetViewModel recipeConditionCheckSetViewModel = new RecipeConditionCheckSetViewModel();
                    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ExternalSensor != null)
                    {
                        recipeConditionCheckSetViewModel.RecipeConditions.ExternalSensor = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ExternalSensor;
                    }
                    var step = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    if (step != null)
                    {
                        recipeConditionCheckSetViewModel.RecipeConditions.TempStabizeSelected = step.TempStabilizeSelected;
                        recipeConditionCheckSetViewModel.RecipeConditions.FinishAutoProfile = step.FinishAutoProfile;
                        recipeConditionCheckSetViewModel.RecipeConditions.ReachTemp = step.ReachTemp;
                        recipeConditionCheckSetViewModel.RecipeConditions.ReachTempValue = step.ReachTempValue;
                        recipeConditionCheckSetViewModel.RecipeConditions.O2Density = step.O2Density;
                        recipeConditionCheckSetViewModel.RecipeConditions.O2DensityValue = step.O2DensityValue;
                        recipeConditionCheckSetViewModel.RecipeConditions.ReachPressure = step.ReachPressure;
                        recipeConditionCheckSetViewModel.RecipeConditions.ReachPressureVG = step.ReachPressureVG;
                        recipeConditionCheckSetViewModel.RecipeConditions.ReachPressureValue = step.ReachPressureValue;
                        recipeConditionCheckSetViewModel.RecipeConditions.PressureStabilizeVG = step.PressureStabilizeVG;
                        recipeConditionCheckSetViewModel.RecipeConditions.PressureStabilizeSelected = step.PressureStabilizeSelected;
                        recipeConditionCheckSetViewModel.RecipeConditions.ProcessTimeToEnd = step.ProcessTimeToEnd;
                    }
                    var result = (windowManager as WindowManager)?.ShowDialogWithTitle(recipeConditionCheckSetViewModel, null, "Condition Check");

                    if (recipeConditionCheckSetViewModel.IsSave)
                    {
                        if (recipeConditionCheckSetViewModel.IsNone)
                        {
                            CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().IsnoneConditionCheck = true;
                        }
                        else
                        {
                            CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().IsnoneConditionCheck = false;
                        }
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ExternalSensor = recipeConditionCheckSetViewModel.RecipeConditions.ExternalSensor;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ExternalSensorName = recipeConditionCheckSetViewModel.RecipeConditions.ExternalSensorName;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().TempStabilizeSelected = recipeConditionCheckSetViewModel.RecipeConditions.TempStabizeSelected;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().FinishAutoProfile = recipeConditionCheckSetViewModel.RecipeConditions.FinishAutoProfile;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ReachTemp = recipeConditionCheckSetViewModel.RecipeConditions.ReachTemp;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ReachTempValue = recipeConditionCheckSetViewModel.RecipeConditions.ReachTempValue;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().O2Density = recipeConditionCheckSetViewModel.RecipeConditions.O2Density;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().O2DensityValue = recipeConditionCheckSetViewModel.RecipeConditions.O2DensityValue;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ReachPressure = recipeConditionCheckSetViewModel.RecipeConditions.ReachPressure;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ReachPressureVG = recipeConditionCheckSetViewModel.RecipeConditions.ReachPressureVG;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureStabilizeVG = recipeConditionCheckSetViewModel.RecipeConditions.PressureStabilizeVG;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ReachPressureValue = recipeConditionCheckSetViewModel.RecipeConditions.ReachPressureValue;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureStabilizeSelected = recipeConditionCheckSetViewModel.RecipeConditions.PressureStabilizeSelected;
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ProcessTimeToEnd = recipeConditionCheckSetViewModel.RecipeConditions.ProcessTimeToEnd;

                    }
                    if (recipeConditionCheckSetViewModel.IsNone)//不存数据处理
                    { }
                    break;
                case "AlarmAction":
                    
                    break;
                case "TempSetting":
                    if (recipeTempSetViewModel is null)
                    {
                        recipeTempSetViewModel = new RecipeTempSetViewModel
                        {
                            RecipeTemplate = RecipeTemplate
                        };
                    }
                    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().TemperatureSets != null)
                    {
                        var tempSets = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                        recipeTempSetViewModel.TemperatureValues.Clear();
                        foreach (var item in tempSets.TemperatureSets.Keys)
                        {
                            recipeTempSetViewModel.TemperatureValues[item] = tempSets.TemperatureSets[item];
                        }
                    }
                    recipeTempSetViewModel.StepType = SelectedRecipeStep.Name;
                    recipeTempSetViewModel.RecipeType = RecipeType;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeTempSetViewModel, null, "Temp Detail"))
                    {
                        if (recipeTempSetViewModel.TemperatureValues != null && recipeTempSetViewModel.TemperatureValues.Count > 0 && recipeTempSetViewModel.IsSave)
                        {
                            if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().TemperatureSets != null)
                            {
                                var tempSets = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                                foreach (var item in recipeTempSetViewModel.TempSetDataList)
                                {
                                    if (tempSets.TemperatureSets.ContainsKey(item.Name))
                                    {
                                        tempSets.TemperatureSets[item.Name] = item;
                                    }
                                }
                            }
                        }
                    }
                    break;
                case "GASSetting":
                    RecipeMFCSettingViewModel recipeMFCSettingViewModel = new RecipeMFCSettingViewModel();
                    //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorRecipeOK", "");
                    var tempMFCSets = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets;
                    if (tempMFCSets != null && tempMFCSets.Count > 0)
                    {
                        foreach (var item in tempMFCSets.Keys)
                        {
                            if (recipeMFCSettingViewModel.MFCSets.ContainsKey(item))
                            {
                                recipeMFCSettingViewModel.MFCSets[item] = tempMFCSets[item];
                            }
                            else
                            {
                                //recipeGASSettingViewModel.MFCSets.Add(item, tempMFCSets[item]);
                                recipeMFCSettingViewModel.MFCSets.Add(item, tempMFCSets[item]);
                            }
                        }
                    }
                    //recipeGASSettingViewModel.MFMSets = new MFMValue() { AlarmValue = tempMFMSets.AlarmValue, IsNotifying = tempMFMSets.IsNotifying, Name = tempMFMSets.Name, Value = tempMFMSets.Value };
                    recipeMFCSettingViewModel.RecipeType = RecipeType;
                    recipeMFCSettingViewModel.RecipeTemplate = RecipeTemplate;
                    if (!(bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeMFCSettingViewModel, null, "MFC Detail"))
                    {
                        //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorPROCManualOK", "");
                        return;
                    }
                    //InvokeClient.Instance.Service.DoOperation($"PM1.SetSensorPROCManualOK", "");
                    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets != null)
                    {
                        if (recipeMFCSettingViewModel.MFCSets != null && recipeMFCSettingViewModel.MFCSets.Count > 0)
                        {
                          //  CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets = recipeMFCSettingViewModel.MFCSets;
                            UpdateMFCShow();
                        }
                    }
                    break;
                case "PressureSetting":

                    RecipePressureSettingViewModel recipePressureSettingViewModel = new RecipePressureSettingViewModel();
                    var tempStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    // recipePressureSettingViewModel.PressureSonsorValue = tempStep.PressureSonserValue;
                    //   recipePressureSettingViewModel.PressureValveAngleValue = tempStep.PressureValveAngle;
                    //  recipePressureSettingViewModel.PressureSettingVG = tempStep.PressureSettingVG;
                    //if (!string.IsNullOrEmpty(tempStep.PressureAlarmTableNo))
                    //{
                    //    if (tempStep.PressureAlarmTableNo.ToLower() == "none")
                    //        recipePressureSettingViewModel.PressureAlarmWatchTable = "None";
                    //    else
                    //        recipePressureSettingViewModel.PressureAlarmWatchTable = tempStep.PressureAlarmTableNo;
                    //}
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipePressureSettingViewModel, null, "Recipe Pressure Setting"))
                    //{
                    //    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault() != null)
                    //    {
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureSonserValue = recipePressureSettingViewModel.PressureSonsorValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureValveAngle = recipePressureSettingViewModel.PressureValveAngleValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureAlarmTableNo = recipePressureSettingViewModel.PressureAlarmWatchTable;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PressureSettingVG = recipePressureSettingViewModel.PressureSettingVG;
                    //       // SelectedRecipeStep.PressureSonserValue = $"{recipePressureSettingViewModel.PressureSonsorValue}";
                    //    }
                    //}
                    break;
                case "RFSetting":
                    //RecipeRFPressureSettingViewModel recipeRFPressureSettingViewModel = new RecipeRFPressureSettingViewModel();
                    //var tempRecipeStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    //recipeRFPressureSettingViewModel.RFSwitch = tempRecipeStep.RFSwitch;
                    //recipeRFPressureSettingViewModel.RFSetPointValue = tempRecipeStep.RFSetpoint;
                    //recipeRFPressureSettingViewModel.C1SetPointValue = tempRecipeStep.C1Setpoint;
                    //recipeRFPressureSettingViewModel.C2SetPointValue = tempRecipeStep.C2Setpoint;
                    //recipeRFPressureSettingViewModel.ForwardPowerAlarmWatchSetPointValue = tempRecipeStep.ForwardPowerAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.PrAlarmWatchSetPointValue = tempRecipeStep.PrAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.PIAlarmWatchSetPointValue = tempRecipeStep.PIAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.C1AlarmWatchSetPointValue = tempRecipeStep.C1AlarmWatchTable;
                    //recipeRFPressureSettingViewModel.C2AlarmWatchSetPointValue = tempRecipeStep.C2AlarmWatchTable;
                    //recipeRFPressureSettingViewModel.VppAlarmWatchSetPointValue = tempRecipeStep.VppAlarmWatchTable;
                    //recipeRFPressureSettingViewModel.VdcAlarmWatchSetPointValue = tempRecipeStep.VdcAlarmWatchTable;
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeRFPressureSettingViewModel, null, "Recipe RF Setting"))
                    //{
                    //    if (CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault() != null)
                    //    {
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RFSwitch = recipeRFPressureSettingViewModel.RFSwitch;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RFSetpoint = recipeRFPressureSettingViewModel.RFSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C1Setpoint = recipeRFPressureSettingViewModel.C1SetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C2Setpoint = recipeRFPressureSettingViewModel.C2SetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ForwardPowerAlarmWatchTable = recipeRFPressureSettingViewModel.ForwardPowerAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PrAlarmWatchTable = recipeRFPressureSettingViewModel.PrAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().PIAlarmWatchTable = recipeRFPressureSettingViewModel.PIAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C1AlarmWatchTable = recipeRFPressureSettingViewModel.C1AlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().C2AlarmWatchTable = recipeRFPressureSettingViewModel.C2AlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().VppAlarmWatchTable = recipeRFPressureSettingViewModel.VppAlarmWatchSetPointValue;
                    //        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().VdcAlarmWatchTable = recipeRFPressureSettingViewModel.VdcAlarmWatchSetPointValue;
                    //        // SelectedRecipeStep.RFSetting = $"{recipeRFPressureSettingViewModel.RFSetPointValue}";
                    //    }
                    //}
                    break;
                case "Loader":
                    RecipeLoaderCommandViewModel recipeLoaderCommandViewModel = new RecipeLoaderCommandViewModel();
                    tempStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    recipeLoaderCommandViewModel.SelectedCmd = tempStep.LoaderCommand;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeLoaderCommandViewModel, null, "Loader Command"))
                    {
                        if (tempStep.LoaderCommand != recipeLoaderCommandViewModel.ReturnString)
                        {
                            ClearLoaderSetValue();
                        }
                        tempStep.LoaderCommand = recipeLoaderCommandViewModel.ReturnString;
                        SelectedRecipeStep.LoaderCommand = recipeLoaderCommandViewModel.ReturnString;
                        SetShowLoaderValuePanel(recipeLoaderCommandViewModel.ReturnString);
                    }
                    break;
                case "Pressure":
                    RecipePressCommandViewModel recipePressCommandViewModel = new RecipePressCommandViewModel();
                    tempStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    recipePressCommandViewModel.SelectedCmd = tempStep.PressCommand;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipePressCommandViewModel, null, "Press Command"))
                    {
                        tempStep.PressCommand = recipePressCommandViewModel.ReturnString;
                        SelectedRecipeStep.PressCommand = recipePressCommandViewModel.ReturnString;
                        SetShowPressPanel(recipePressCommandViewModel.ReturnString);
                    }
                    break;
                case "PressureWait":
                    RecipePressureWaitViewModel recipePressureWaitViewModel = new RecipePressureWaitViewModel();
                    tempStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    var destinationStep = (Step)CloneUtil.CloneObject(tempStep);
                    destinationStep.StepNo = tempStep.StepNo;
                    destinationStep.PressWaitUnit = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.APC.PressureUnit");
                    recipePressureWaitViewModel.SelectedStep = destinationStep;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipePressureWaitViewModel, null, "Press WaitSet"))
                    {
                        tempStep.PressIsWait = recipePressureWaitViewModel.SelectedStep.PressIsWait;
                        tempStep.PressLowWait = recipePressureWaitViewModel.SelectedStep.PressLowWait;
                        tempStep.PressHighWait = recipePressureWaitViewModel.SelectedStep.PressHighWait;
                        tempStep.PressWaitUnit = recipePressureWaitViewModel.SelectedStep.PressWaitUnit;
                    }
                    break;
                case "Pattern":
                    RecipeGasPanelSettingViewModel recipeGasPanelSettingViewModel = new RecipeGasPanelSettingViewModel();
                    recipeGasPanelSettingViewModel.CurrentRecipe = CurrentRecipe;
                    recipeGasPanelSettingViewModel.SelectedStepName = $"{SelectedRecipeStep.StepNo}:{SelectedRecipeStep.Name}";
                    recipeGasPanelSettingViewModel.ChangedStepEvent += RecipeGasPanelSettingViewModel_ChangedStepEvent;
                    recipeGasPanelSettingViewModel.SelectedStep = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeGasPanelSettingViewModel, null, "Valve"))
                    {

                    }
                    break;
                case "BoatElevatorSetting":
                    //BoatElevatorSettingViewModel boatElevatorSettingViewModel = new BoatElevatorSettingViewModel();
                    //boatElevatorSettingViewModel.SelectedRecipeStep = SelectedRecipeStep;
                    //if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(boatElevatorSettingViewModel, null, "BoatElevator Setting"))
                    //{
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ZAxisPosition = boatElevatorSettingViewModel.SelectedRecipeStep.ZAxisPosition;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().ZAxisSpeed = boatElevatorSettingViewModel.SelectedRecipeStep.ZAxisSpeed;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotatePosition = boatElevatorSettingViewModel.SelectedRecipeStep.RotatePosition;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotateSpeed = boatElevatorSettingViewModel.SelectedRecipeStep.RotateSpeed;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotateInterval = boatElevatorSettingViewModel.SelectedRecipeStep.RotateInterval;
                    //    CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().RotateDirection = boatElevatorSettingViewModel.SelectedRecipeStep.RotateDirection;
                    //}
                    break;
                case "AUX":
                    if (SelectedRecipeStep == null || SelectedRecipeStep.AUXSets.Count == 0)
                    { return; }
                    RecipeAUXSetViewModel recipeAUXSetViewModel = new RecipeAUXSetViewModel();
                    List<AUXData> auxDataList = SelectedRecipeStep.AUXSets.Values.OrderBy(x => int.Parse(x.ControlName)).ToList();
                    auxDataList.ForEach(x => recipeAUXSetViewModel.AUXDataList.Add(x));
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeAUXSetViewModel, null, "AUX Set"))
                    {
                    }
                    break;
                case "RecipeHeader":
                    RecipeHeaderViewModel recipeHeaderViewModel = new RecipeHeaderViewModel();
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeHeaderViewModel, null, "Recipe Header"))
                    {
                    }
                    break;
                case "Combination":
                    RecipeCombinationViewModel recipeCombinationViewModel = new RecipeCombinationViewModel();
                    recipeCombinationViewModel.CombinationData = new Combination(CurrentRecipe.ConfigItems);
                    recipeCombinationViewModel.CombinationData.ChangedValueEvent += CombinationData_ChangedValueEvent;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeCombinationViewModel, null, "Combination"))
                    {
                        recipeCombinationViewModel.CombinationData.SetValueToParam();
                    }
                    break;
                case "VPDataList":
                    RecipeVPItemSelectViewModel recipeVPItemSelectViewModel = new RecipeVPItemSelectViewModel();
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeVPItemSelectViewModel, null, "VP Item Select"))
                    {
                    }
                    break;
                case "AbortRecipe":
                    Step currentStep = CurrentRecipe.Steps.FirstOrDefault(x => x.StepNo == SelectedRecipeStep.StepNo);
                    StringParam abortCombination = CurrentRecipe.ConfigItems.FirstOrDefault(x => x.Name == "Combination.AbortRecipe") as StringParam;
                    if (string.IsNullOrEmpty(abortCombination.Value))
                    {
                        DialogBox.ShowError("Please select abort recipe first!");
                    }
                    var retRecipe = RecipeTableSelect.ShowDialog($"Furnace\\abort", abortCombination.Value, false);
                    if (!string.IsNullOrEmpty(retRecipe))
                    {
                        currentStep.AbortRecipeTableIndex = retRecipe;
                        SelectedRecipeStep.AbortRecipeTableIndex = retRecipe;
                    }
                    break;
                case "SkipOrWait":
                    RecipeSkipWaitCommandViewModel recipeSkipWaitCommandViewModel = new RecipeSkipWaitCommandViewModel();
                    recipeSkipWaitCommandViewModel.SkipWait = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().SkipWait;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeSkipWaitCommandViewModel, null, "Skip or wait command"))
                    {
                        CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().SkipWait = recipeSkipWaitCommandViewModel.RtnString;
                        SelectedRecipeStep.SkipWait = recipeSkipWaitCommandViewModel.RtnString;
                    }
                    break;
                default:
                    break;
            }

        }

        private void CombinationData_ChangedValueEvent(string type, string value)
        {
            string prefix = "";
            switch (type)
            {
                case "SubRecipe":
                    break;
                case "AlarmRecipe":
                    break;
                case "AbortRecipePath":
                    break;
                case "AlarmCondition":
                    break;
                case "LeakCheck":
                    break;
                case "PressAPCPID":
                    prefix = $"Parameter\\APCPID";
                    var pressAPCDictData = LoadData(prefix, value);
                    foreach (var item in CurrentRecipe.Steps)
                    {
                        if (item.TemperaturePID.Contains(","))
                        {
                            var pidList = item.TemperaturePID.Split(',');
                            if (pidList.Count() > 2)
                            {
                                pidList[0] = $"{prefix}\\{value}";
                                int pressAPCTempNo = 0;
                                int.TryParse(pidList[1], out pressAPCTempNo);
                                if (pressAPCDictData != null && pressAPCDictData.ContainsKey(pressAPCTempNo))
                                {
                                    pidList[2] = pressAPCDictData[pressAPCTempNo];
                                }
                                item.TemperaturePID = string.Join(",", pidList);
                            }
                        }
                    }
                    break;
                case "TempCorrection":
                    prefix = $"Parameter\\TempCorrection";
                    var tempCorDictData = LoadData(prefix, value);
                    foreach (var item in CurrentRecipe.Steps)
                    {
                        if (item.TemperaturePID.Contains(","))
                        {
                            var pidList = item.TemperaturePID.Split(',');
                            if (pidList.Count() > 2)
                            {
                                pidList[0] = $"{prefix}\\{value}";
                                int tempCorTempNo = 0;
                                int.TryParse(pidList[1], out tempCorTempNo);
                                if (tempCorDictData != null && tempCorDictData.ContainsKey(tempCorTempNo))
                                {
                                    pidList[2] = tempCorDictData[tempCorTempNo];
                                }
                                item.TemperaturePID = string.Join(",", pidList);
                            }
                        }
                    }
                    break;
                case "TempPID":
                    prefix = $"Parameter\\TempPID";
                    var tempPIDDictData = LoadData(prefix, value);
                    foreach (var item in CurrentRecipe.Steps)
                    {
                        if (item.TemperaturePID.Contains(","))
                        {
                            var pidList = item.TemperaturePID.Split(',');
                            if (pidList.Count() > 2)
                            {
                                pidList[0] = $"{prefix}\\{value}";
                                int tempTempNo = 0;
                                int.TryParse(pidList[1], out tempTempNo);
                                if (tempPIDDictData != null && tempPIDDictData.ContainsKey(tempTempNo))
                                {
                                    pidList[2] = tempPIDDictData[tempTempNo];
                                }
                            }
                            item.TemperaturePID = string.Join(",", pidList);
                        }
                    }
                    break;
                case "ProfileCondition":
                    break;
                default:
                    break;
            }
        }

        public TempPIDParameterData CurrentParameter { get; set; } = new TempPIDParameterData();
        private readonly ParameterProvider _parameterProvider = new ParameterProvider();

        private Dictionary<int, string> LoadData(string PrefixPath, string name)
        {
            var recipeContent = _parameterProvider.LoadParameter(PrefixPath, name);

            if (string.IsNullOrEmpty(recipeContent))
            {
                System.Windows.MessageBox.Show($"{PrefixPath}\\{name} is empty, please confirm the file is valid.");
                return null;
            }
            var parameter = new TempPIDParameterData();
            parameter.PrefixPath = PrefixPath;
            parameter.Name = name;
            parameter.InitData(PrefixPath, name, recipeContent, "");
            var dictData = new Dictionary<int, string>();
            if (parameter != null && parameter.Steps.Count > 0)
            {
                foreach (var item in parameter.Steps)
                {
                    dictData.Add(item.StepNo, item.Name);
                }
            }
            return dictData;
        }

        public void LowPressWaitTextChanged(object sender, object item)
        {
            if (SelectedRecipeStep == null)
            {
                DialogBox.ShowWarning("The current step is empty!");
                return;
            }
            SelectExistViewModel selectExistViewModel = new SelectExistViewModel();
            selectExistViewModel.ProductZeroStr = SelectedRecipeStep.PressLowPressWait;
            var windowManager = IoC.Get<IWindowManager>();
            var dialogReturn = (bool)(windowManager as WindowManager)?.ShowDialogWithTitle(selectExistViewModel, null, "Select");
            if ((bool)dialogReturn)
            {
                SelectedRecipeStep.PressLowPressWait = selectExistViewModel.DialogResultString;
            }
        }

        public void RecipeSave()
        {
            List<string> noNeedEndRecipeType = new List<string>() {
            "reset",
            "idle",
            "abort",
            "sub"
            };
            var SelectedStep = this.CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
            //if (SelectedStep != null)
            //{
            //    SelectedStep.LoaderValue = GetSaveLoaderValue(SelectedStep.LoaderCommand);
            //    SelectedStep.PressValue = GetSavePressValue(SelectedStep.PressCommand);
            //}
            RecipePermissionSelectViewModel dialog = new RecipePermissionSelectViewModel("Save recipe and permission", CurrentRecipe.RecipePermission);
            WindowManager wm = new WindowManager();
            bool? dialogReturn = wm.ShowDialog(dialog);
            if (!dialogReturn.HasValue || !dialogReturn.Value)
                return;
            List<string> names = new List<string>();
            string filmFormula = string.Empty;
            Step step = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault();
            if (string.IsNullOrEmpty(CurrentRecipe.Name))
            {
                DialogBox.ShowWarning("Recipe name is empty,can not save!");
                return;
            }
            bool bStandby = false, bEnd;
            foreach (Step recipestep in CurrentRecipe.Steps)
            {
                if (recipestep.StepNo == 0)
                    bStandby = true;

                //DialogBox.ShowWarning($"{recipestep.TemperatureControlMode}");
                //DialogBox.ShowWarning($"{recipestep.TemperatureCorrect}");
                //DialogBox.ShowWarning($"{recipestep.TemperaturePID}");
                //if (string.IsNullOrEmpty(filmFormula))
                //    filmFormula = recipestep.FilmThickFormula;
                //if (filmFormula != recipestep.FilmThickFormula)
                //{
                //    DialogBox.ShowWarning($"The step film thicknesss formula of step number {recipestep.StepNo} is different,can not save!");
                //    return;
                //}
                if (string.IsNullOrEmpty(recipestep.Name) || string.IsNullOrEmpty(recipestep.Time))
                {
                    if (recipestep.Name != "Standby")
                    {
                        DialogBox.ShowWarning($"The step name or time of step number {recipestep.StepNo} is empty,can not save!");
                        return;
                    }
                }
                if (names.Where(x => x == recipestep.Name).FirstOrDefault() != null)
                {
                    DialogBox.ShowWarning("Step name cannot be duplicated!");
                    return;
                }
                names.Add(recipestep.Name);
                bEnd = bStandby ? recipestep.StepNo == CurrentRecipe.Steps.Count - 1 : recipestep.StepNo == CurrentRecipe.Steps.Count;
                //// "reset/Idle/abort/sub"类型的Recipe不需要End结尾
                if (bEnd == true && noNeedEndRecipeType.Contains(CurrentRecipe.RecipeChamberType.ToLower()))
                {
                    bEnd = false;
                }
                //是否是最后一步
                if (bEnd)
                {

                    if (recipestep.Command.ToUpper() != "END")
                    {
                        DialogBox.ShowWarning("The step command of last step must be 'END',please check!");
                        return;
                    }
                    //else
                    //{
                    //    if (recipestep.ZAxisPosition.ToLower() != "homeposition")
                    //    {
                    //        DialogBox.ShowWarning("The step z axis position of last step must be 'HomePosition',please check!");
                    //        return;
                    //    }
                    //}
                }
            }
            // step.SetStepValues(SelectedRecipeStep);
            this.CurrentRecipe.Revisor = BaseApp.Instance.UserContext.LoginName;
            this.CurrentRecipe.ReviseTime = DateTime.Now;
            this.CurrentRecipe.RecipeLevel = this.LevelDisplay;
            this.CurrentRecipe.RecipePermission = dialog.RecipeComment;

            var result = this._recipeProvider.SaveRecipe(CurrentRecipe.PrefixPath, CurrentRecipe.Name, CurrentRecipe.GetXmlString());
            if (result)
                ((Window)GetView()).Close();
        }

        public List<ConfigNode> GetMfcItem()
        {
            this.SystemName = "System";
            ConfigNodes = SystemConfigProvider.Instance.GetConfigTree(SystemName).SubNodes;
            var MfcItems = ConfigNodes.Where(x => x.Display == "Parameter").FirstOrDefault().SubNodes.Where(y => y.Name == "MFC").FirstOrDefault().SubNodes;
            return MfcItems;
        }

        public void RecipeCancel()
        {
            if (DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM, " You confirm that you want to unsave the recipe and exit the interface?") == DialogButton.No)
                return;
            ((Window)GetView()).Close();
        }

        public void PressPIDChick()
        {
            var windowManager = IoC.Get<IWindowManager>();
            StringParam pressAPC = CurrentRecipe.ConfigItems.FirstOrDefault(x => x.Name == "Combination.PressAPCPID") as StringParam;
            if (pressAPC == null)
            {
                DialogBox.ShowDialog(DialogButton.Cancel, DialogType.INFO, "Please set the combination file first");
                return;
            }
            APCPIDEditViewModel aPCPIDEditViewModel = new APCPIDEditViewModel();
            aPCPIDEditViewModel.IsEditEnabled = false;
            aPCPIDEditViewModel.CurrentRecipe = CurrentRecipe;
            var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(aPCPIDEditViewModel, null, "APC PID Table");
            if ((bool)rtn && SelectedRecipeStep != null)
                SelectedRecipeStep.PressPID = aPCPIDEditViewModel.RetrunString;
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            if (CurrentRecipe.Steps != null && CurrentRecipe.Steps.Count > 0 && CheckValueChange(data))
            {
                UpdateRecipeGASSetting(data);
                //SelectStep(CurrentRecipe.Steps[EditRecipeStepNo]);
            }
            UpdateGASSetting();
            oldresult = data;
        }

        Dictionary<string, object> oldresult;

        private bool CheckValueChange(Dictionary<string, object> result)
        {
            Dictionary<string, object> temp = result;
            if (oldresult == null)
            {
                oldresult = result;
                return true;
            }
            else
            {
                List<string> strkeys = new List<string>();
                foreach (var key in result.Keys)
                {
                    if (_subscribedKeys.Contains(key) && oldresult.ContainsKey(key) && result.ContainsKey(key))
                    {
                        if (result[key].GetType() == typeof(AITValveData) && ((AITValveData)oldresult[key]).VirtualFeedback != ((AITValveData)result[key]).VirtualFeedback)
                        {
                            return true;
                        }
                        else if (result[key].GetType() == typeof(AITMfcData) && ((AITMfcData)oldresult[key]).VirtualSetPoint != ((AITMfcData)result[key]).VirtualSetPoint)
                        {
                            return true;
                        }
                        else if (result[key].GetType() == typeof(bool) && (bool)oldresult[key] != (bool)result[key])
                        {
                            return true;
                        }
                    }
                }
            }

            return false;
        }

        public void MFCTextChanged(string type, object sender, object item)
        {
            if (!string.IsNullOrEmpty(type) && item != null && sender != null)
            {
                MFCData mFCData = (MFCData)item;
                string value = ((TextBox)sender).Text;
                switch (type)
                {
                    case "Value":
                        InvokeClient.Instance.Service.DoOperation($"PM1.{mFCData.DisplayName}.SetMfcVirtualValue", $"{value};{mFCData.Rampng};{mFCData.AlarmValue}");
                        break;
                    case "Rampng":
                        InvokeClient.Instance.Service.DoOperation($"PM1.{mFCData.DisplayName}.SetMfcVirtualValue", $"{mFCData.SetValueParam};{value};{mFCData.AlarmValue}");
                        SetRampngValue(mFCData.DisplayName, value);
                        break;
                    default:
                        break;
                }
            }
        }

        private void SetRampngValue(string name, string value)
        {
          

        }

        private void UpdateMFCShow()
        {
            var mfcDict = CurrentRecipe.Steps.Where(x => x.StepNo == SelectedRecipeStep.StepNo).FirstOrDefault().MFCSets;
            //foreach (var item in mfcDict)
            //{
            //    var mfc = MFCDataList.FirstOrDefault(x => x.Name == item.Key.Replace(".Flow", ""));
            //    if (mfc != null)
            //    {
            //        mfc.IsCheck = item.Value.IsCheck;
            //    }
            //}

        }

        private void UpdateRecipeGASSetting(Dictionary<string, object> result)
        {
            var stepNo = 0;
            if (!_isStandbyCheckedSelect)
                stepNo = SelectedRecipeStep.StepNo;
            var step = CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault();
            if (step != null)
            {
                var mfcSets = CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault().MFCSets;
                var valveSets = CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault().ValveSets;
                foreach (var key in result.Keys)
                {
                    //if (result[key].GetType() == typeof(AITValveData))
                    //{
                    //    var valveData = (AITValveData)result[key];
                    //    if (valveSets.ContainsKey(valveData.DeviceName))
                    //    {
                    //        valveSets[valveData.DeviceName] = valveData.VirtualFeedback ? "Open" : "Close";
                    //    }
                    //}else
                    //if (result[key].GetType() == typeof(AITMfcData))
                    //{
                    //    var mfcData = (AITMfcData)result[key];
                    //    var name = $"{mfcData.DeviceName}.Flow";
                    //    if (mfcSets.ContainsKey(name))
                    //    {
                    //        mfcSets[name].SetValueParam.Value = mfcData.VirtualSetPoint.ToString();
                    //        mfcSets[name].Rampng.Value = mfcData.VirtualRamping.ToString();
                    //        mfcSets[name].AlarmValue = mfcData.VirtualAlarmWatchTable;
                    //    }
                    //}
                }
                CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault().MFCSets = mfcSets;
                CurrentRecipe.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault().ValveSets = valveSets;
            }
        }

        private void UpdateGASSetting()
        {
            if (_isStandbyCheckedSelect)
                return;

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

            if (MFCDataList.Count == 0)
            {
                for (int i = 0; i < mfcDatas.Count; i++)
                {
                    if (mfcDatas[i] == null)
                        continue;
                    MFCData mFCData;
                    if (SelectedRecipeStep != null )
                    {
                        mFCData = SelectedRecipeStep.MFCSets[$"{mfcDatas[i].DeviceName}.Flow"];
                        MFCDataList.Add(mFCData);
                  
                        && SelectedRecipeStep.MFCSets.ContainsKey($"{mfcDatas[i].DeviceName}.Flow")
                        MFCDataList.Add(new MFCData()
                        {
                            Name = mfcDatas[i].DeviceName,
                            DisplayName = mfcDatas[i].DisplayName,
                            SetValueParam =new DoubleParam() { Name = "SetValue", Value = mfcDatas[i].VirtualSetPoint.ToString() },
                            Rampng =new DoubleParam() { Name = "Rampng", Value = mfcDatas[i].VirtualRamping.ToString() },
                            Unit = mfcDatas[i].Unit,
                        });
            }
            else
            {
                for (int i = 0; i < MFCDataList.Count; i++)
                {
                    if (mfcDatas[i] == null)
                        continue;

                    MFCDataList[i].Name = mfcDatas[i].DeviceName;
                    MFCDataList[i].DisplayName = mfcDatas[i].DisplayName;
                    MFCDataList[i].SetValueParam.Value = mfcDatas[i].VirtualSetPoint.ToString();
                    MFCDataList[i].Rampng.Value = mfcDatas[i].VirtualRamping.ToString();
                    MFCDataList[i].Unit = mfcDatas[i].Unit;
                };
            }
        }

        public void SelecteTable()
        {
            var steps = CurrentRecipe.Tables.FirstOrDefault(x => x.Index == CurrentRecipe.TableIndex).TableData.Steps;
            steps.Clear();
            CurrentRecipe.Steps.ToList().ForEach(x =>
            {
                var tempStep = (Step)CloneUtil.CloneObject(x);
                tempStep.StepNo = x.StepNo;
                steps.Add(tempStep);
            });
            CurrentRecipe.StepCloneChangedIndex();
            int getIndex = RecipeTableSelect.ShowDialogGetTableIndex(CurrentRecipe, RecipeType);
            SelectStep(CurrentRecipe.Steps.FirstOrDefault());
            //if (getIndex!=-1)
            //{
            //    CurrentRecipe.Steps.Clear();
            //    CurrentRecipe.Tables.FirstOrDefault(x => x.Index == (getIndex + 1)).TableData.Steps.ToList().ForEach(x => CurrentRecipe.Steps.Add((Step)CloneUtil.CloneObject(x)));
            //    SelectStep(CurrentRecipe.Steps.FirstOrDefault());
            //}
        }
    }

}