FurnaceELK/Furnace/FurnaceUI/Views/Parameter/AlarmConditionEditViewModel.cs

using Aitex.Core.RT.SCCore;
using Caliburn.Micro;
using Caliburn.Micro.Core;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Windows;
//using System.Windows.Forms;
using System.Windows.Controls;
using FurnaceUI.Client;
using FurnaceUI.Models;
using FurnaceUI.Views.Editors;
using Aitex.Core.Util;
using Aitex.Core.Common.DeviceData;
using MECF.Framework.UI.Client.CenterViews.Parameter;
using MECF.Framework.Common.ParameterCenter;
using OpenSEMI.Ctrlib.Controls;
using MECF.Framework.UI.Client.CenterViews.Editors.Sequence;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.Jobs;

namespace FurnaceUI.Views.Parameter
{
    public class AlarmConditionEditViewModel : FurnaceUIViewModelBase
    {

        private UIElement _parent;

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

        }

        [Subscription("Scheduler.ControlJobList")]
        public List<ControlJobInfo> ControlJobs
        {
            get;
            set;
        }
        [Subscription("Scheduler.SecondPj")]
        public List<ProcessJobInfo> SecondPjList
        {
            get;
            set;
        }

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

        private string _newPM1EntityStatus;
        public string NewPM1EntityStatus
        {
            get { return _newPM1EntityStatus; }
            set { _newPM1EntityStatus = value; NotifyOfPropertyChange("NewPM1EntityStatus"); }
        }

        public string RecipeType { get; set; }

        private readonly ParameterProvider _parameterProvider = new ParameterProvider();

        private Dictionary<string, ObservableCollection<ParameterTemplateColumnBase>> ParameterTemplate;
        public AlarmConditionParameterData CurrentParameter { get; set; } = new AlarmConditionParameterData();

        private ParameterFormatBuilder _columnBuilder = new ParameterFormatBuilder();

        private AlarmConditionTable _selectedParameterStep;
        public AlarmConditionTable SelectedParameterStep
        {
            get => _selectedParameterStep;
            set
            {
                if (value != null)
                {
                    _selectedParameterStep = value;
                    NotifyOfPropertyChange("SelectedParameterStep");
                }
                else
                {
                    _selectedParameterStep = null;
                    NotifyOfPropertyChange("SelectedParameterStep");
                }
            }
        }

        private AlarmConditionTable _copyParameterStep;

        public AlarmConditionTable CopyParameterStep
        {
            get => _copyParameterStep;
            set
            {
                _copyParameterStep = value;
                NotifyOfPropertyChange(nameof(CopyParameterStep));
            }
        }

        private bool _isCopyEnabled = false;

        public bool IsCopyEnabled
        {
            get => _isCopyEnabled;
            set
            {
                _isCopyEnabled = value;
                NotifyOfPropertyChange("IsCopyEnabled");
            }
        }

        private bool _prevStepOverwriteIsEnabled;

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

        private bool _prevStepInsertIsEnabled;

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

        private bool _prevStepItemIsEnabled;

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

        private bool _currStepDeleteIsEnabled;

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

        private bool _multStepsDeleteIsEnabled;

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

        private string _eventSetting;

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

        private bool _isEnableEdit = true;


        public bool IsEnableEdit
        {
            get => _isEnableEdit;
            set
            {
                _isEnableEdit = value;
                NotifyOfPropertyChange(nameof(IsEnableEdit));
            }
        }

        public string EditRecipeStepName { get; set; }

        public ObservableCollection<AlarmConditionHeaterTemp> CurrentHeaterTempList { get; set; } = new ObservableCollection<AlarmConditionHeaterTemp>();
        public ObservableCollection<AlarmConditionBoatTemp> CurrentBoatTempList { get; set; } = new ObservableCollection<AlarmConditionBoatTemp>();
        public ObservableCollection<AlarmConditionMFCDeviation> CurrentMFCDeviationList { get; set; } = new ObservableCollection<AlarmConditionMFCDeviation>();
        public ObservableCollection<AlarmConditionMFCOther> CurrentMFCOtherList { get; set; } = new ObservableCollection<AlarmConditionMFCOther>();
        public ObservableCollection<AlarmConditionPress> CurrentPressList { get; set; } = new ObservableCollection<AlarmConditionPress>();
        public ObservableCollection<AlarmConditionAUX> CurrentAUXList { get; set; } = new ObservableCollection<AlarmConditionAUX>();
        public ObservableCollection<AlarmConditionHWILK> CurrentHWILKList { get; set; } = new ObservableCollection<AlarmConditionHWILK>();
        public ObservableCollection<AlarmConditionHardSoft> CurrentHardSoftList { get; set; } = new ObservableCollection<AlarmConditionHardSoft>();
        public ObservableCollection<AlarmConditionDataBase> CurrentContDownList { get; set; } = new ObservableCollection<AlarmConditionDataBase>();
        public ObservableCollection<AlarmConditionLanLineDown> CurrentDeviceNetLineDownList { get; set; } = new ObservableCollection<AlarmConditionLanLineDown>();
        public ObservableCollection<AlarmConditionSensor> CurrentSensorList { get; set; } = new ObservableCollection<AlarmConditionSensor>();
        public ObservableCollection<AlarmConditionOther> CurrentOtherList { get; set; } = new ObservableCollection<AlarmConditionOther>();

        public string TempStringType = "Heater";
        public string MFCStringType = "Flow";

        public string RdoStringType = "Temp";

        public string ReturnString = "1:";

        public string _selectTableString = "";

        public void SetCmdIsEnabled()
        {
            if (CurrentParameter.Steps == null || CurrentParameter.Steps.Count == 0)
            {
                SelectedStepName = "";
                SelectedParameterStep = null;
                PrevStepOverwriteIsEnabled = false;
                PrevStepInsertIsEnabled = false;
                PrevStepItemIsEnabled = false;
                CurrStepDeleteIsEnabled = false;
                MultStepsDeleteIsEnabled = false;
                SettingButtonEnable = false;
            }
        }

        public int SelectedStepNo { get; set; }

        private string _selectedStepName;

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


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


        public string ParameterType { get; set; }

        private Visibility _tempVisibility = Visibility.Visible;
        public Visibility TempVisibility
        {
            get => _tempVisibility;
            set
            {
                _tempVisibility = value;
                NotifyOfPropertyChange(nameof(TempVisibility));
            }
        }

        private Visibility _mFCVisibility = Visibility.Hidden;
        public Visibility MFCVisibility
        {
            get => _mFCVisibility;
            set
            {
                _mFCVisibility = value;
                NotifyOfPropertyChange(nameof(MFCVisibility));
            }
        }

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

        private Visibility _aUXVisibility = Visibility.Hidden;
        public Visibility AUXVisibility
        {
            get => _aUXVisibility;
            set
            {
                _aUXVisibility = value;
                NotifyOfPropertyChange(nameof(AUXVisibility));
            }
        }

        private Visibility _hWILKVisibility = Visibility.Hidden;
        public Visibility HWILKVisibility
        {
            get => _hWILKVisibility;
            set
            {
                _hWILKVisibility = value;
                NotifyOfPropertyChange(nameof(HWILKVisibility));
            }
        }

        private Visibility _hardSoftVisibility = Visibility.Hidden;
        public Visibility HardSoftVisibility
        {
            get => _hardSoftVisibility;
            set
            {
                _hardSoftVisibility = value;
                NotifyOfPropertyChange(nameof(HardSoftVisibility));
            }
        }

        private Visibility _contDownVisibility = Visibility.Hidden;
        public Visibility ContDownVisibility
        {
            get => _contDownVisibility;
            set
            {
                _contDownVisibility = value;
                NotifyOfPropertyChange(nameof(ContDownVisibility));
            }
        }

        private Visibility _sensorVisibility = Visibility.Hidden;
        public Visibility SensorVisibility
        {
            get => _sensorVisibility;
            set
            {
                _sensorVisibility = value;
                NotifyOfPropertyChange(nameof(SensorVisibility));
            }
        }

        private Visibility _otherVisibility = Visibility.Hidden;
        public Visibility OtherVisibility
        {
            get => _otherVisibility;
            set
            {
                _otherVisibility = value;
                NotifyOfPropertyChange(nameof(OtherVisibility));
            }
        }


        private Visibility _tempMainHeaterVisibility = Visibility.Visible;

        public Visibility TempMainHeaterVisibility
        {
            get => _tempMainHeaterVisibility;
            set
            {
                _tempMainHeaterVisibility = value;
                NotifyOfPropertyChange(nameof(TempMainHeaterVisibility));
            }

        }

        private Visibility _tempBoatVisibility = Visibility.Hidden;

        public Visibility TempBoatVisibility
        {
            get => _tempBoatVisibility;
            set
            {
                _tempBoatVisibility = value;
                NotifyOfPropertyChange(nameof(TempBoatVisibility));
            }

        }
        private string SelectCommandName { get; set; }
        public string ResultParameterStr { get; set; }
        public AlarmConditionEditViewModel(string strPrefixPath, string strRecipeName, string permission = "")
        {
            _parameterProvider.GetParameterFormatXml(strPrefixPath);
            ParameterTemplate = _parameterProvider.GetGroupParameterTemplate();
            _columnBuilder.Build(strPrefixPath);
            CurrentParameter.PrefixPath = strPrefixPath;
            CurrentParameter.Name = strRecipeName;
            CurrentParameter.Permission = permission;
        }
        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();
            LoadViewData();
            SetCmdIsEnabled();
            if (SelectedParameterStep.AUXList != null && SelectedParameterStep.AUXList.Count > 0)
            {
                string aUXUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.AUXAlarmCondtionUnit");
                if (aUXUnit != null)
                {
                    SelectedParameterStep.AUXList.ToList().ForEach(s =>
                    {
                        s.AlertTempData.Unit = aUXUnit;
                        s.AlarmTempData.Unit = aUXUnit;
                    });
                }
                var scList = QueryDataClient.Instance.Service.GetConfigItemList();
                var auxList = scList.Where(a => a.Path.StartsWith("PM1.RecipeEditParameter.AUX.")).ToList();
                auxList = auxList.Where(a => a.PathName.EndsWith("Display")).ToList();
                for (int i = 0; i < SelectedParameterStep.AUXList.Count; i++)
                {
                    if (i < auxList.Count)
                    {
                        SelectedParameterStep.AUXList[i].AUXName = (string)auxList[i].Value;
                    }
                }
            }

        }

        private void LoadData()
        {
            var recipeContent = _parameterProvider.LoadParameter(CurrentParameter.PrefixPath, CurrentParameter.Name);

            if (string.IsNullOrEmpty(recipeContent))
            {
                if (!string.IsNullOrEmpty(RecipeType) && RecipeType.ToLower() == "process")
                {
                    System.Windows.MessageBox.Show($"{CurrentParameter.PrefixPath}\\{CurrentParameter.Name} is empty, please confirm the file is valid.");
                }
                return;
            }
            CurrentParameter.TableNumber = _columnBuilder.TableNumber;
            CurrentParameter.ChamberType = _columnBuilder.ChamberType;
            CurrentParameter.InitData(CurrentParameter.PrefixPath, CurrentParameter.Name, recipeContent, "");

        }
        private void LoadViewData()
        {
            if (CurrentParameter.Steps != null && CurrentParameter.Steps.Count > 0)
            {
                SelectedStepName = CurrentParameter.Steps[0].Name;
                SelectedStepNo = CurrentParameter.Steps[0].StepNo;
                SelectTable(CurrentParameter.Steps[0]);
            }
        }


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

        private void StepListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var obj = sender;
            var eV = e;
        }


        public void SelectTable(object step)
        {
            if (step != null && step is AlarmConditionTable step1)
            {
                var SelectedStep = this.CurrentParameter.Steps.Where(x => x.StepNo == step1.StepNo).FirstOrDefault();
                SelectedStep.IsChecked = true;
                SelectedStepNo = step1.StepNo;
                string strName = step1.Name.Trim();
                SelectedStepName = strName;
                SelectedParameterStep = (AlarmConditionTable)SelectedStep;
                RdoCmdSelectTypeChecked(RdoStringType);
                //SelectedParameterStep = new TempPIDTable(CurrentParameter, SelectedStepNo);
            }
            SetCmdIsEnabled();
        }

        public void SelectTableChecked(object step)
        {
            RdoCmdSelectTableChecked(step);
        }

        public void RdoCmdSelectTableChecked(object step)
        {
            if (step != null && step is AlarmConditionTable step1)
            {
                var alarmConditionView = ((AlarmConditionEditView)((Window)GetView()).Content);
                alarmConditionView.StepListView.SelectedItem = step;
                SelectTable(step);
            }
        }


        public void StepListViewSelectionChanged(object sender, EventArgs e)
        {
            var temp = (ListView)sender;
            var step1 = ((ParameterTable)temp.SelectedItem);
            if (step1 != null)
            {
                step1.IsChecked = true;
                var SelectedStep = this.CurrentParameter.Steps.Where(x => x.StepNo == step1.StepNo).FirstOrDefault();
                SelectedStep.IsChecked = true;
                SelectedStepNo = step1.StepNo;
                string strName = step1.Name.Trim();
                SelectedStepName = strName;
                SelectedParameterStep = (AlarmConditionTable)SelectedStep;
                RdoCmdSelectTypeChecked(RdoStringType);
                //SelectedParameterStep = new TempPIDTable(CurrentParameter, SelectedStepNo);
            }
            SetCmdIsEnabled();
        }
        //public void SetValue(object sender, string isFullKeyboard = "")
        //{
        //    string value = ((TextBox)sender).Text;
        //    if (!string.IsNullOrEmpty(isFullKeyboard))
        //    {
        //        FullKeyboard fullKeyboard1 = new FullKeyboard("", value);
        //        if ((bool)fullKeyboard1.ShowDialog())
        //        {
        //            ((TextBox)sender).Text = fullKeyboard1.ValueString;
        //        }
        //    }
        //    else
        //    {
        //        NumberKeyboard fullKeyboard = new NumberKeyboard("", value);
        //        if ((bool)fullKeyboard.ShowDialog())
        //        {
        //            ((TextBox)sender).Text = fullKeyboard.ValueString;
        //        }
        //    }
        //}
        public void StepEdit(string stepEditCmd)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch (stepEditCmd)
            {
                case "Append":
                    CurrentParameter.Steps.Add(CurrentParameter.CreateStep());
                    int TempSelectIndex = 0;
                    SelectTable(CurrentParameter.Steps[TempSelectIndex]);
                    break;
                case "InsertCopy":
                    InsertCopyStep();
                    break;
                case "OverWrite"://任何步骤的内容都可以覆盖到选定的步骤中
                    OverWriteStep();
                    break;
                case "PrevStepOverwrite"://用上一步的内容覆盖所选步骤
                    PrevStepOverwriteStep();
                    break;
                case "PrevStepInsert"://在选定步骤之前，插入带有前一步内容的新步骤。
                    InsertPrevStep();
                    break;
                case "PrevStepItem":
                    break;
                case "MultStepsDelete":
                    break;
                default:
                    break;
            }
        }

        private void OverWriteStep()
        {
            var windowManager = IoC.Get<IWindowManager>();
            if (CurrentParameter == null) return;

        }

        private void PrevStepOverwriteStep()
        {
            int index = -1;
            index = SelectedParameterStep.StepNo;
            if (index > 1)
            {
                CurrentParameter.CloneStep(CurrentParameter.Steps.Where(x => x.StepNo == SelectedParameterStep.StepNo).FirstOrDefault(), CurrentParameter.Steps.Where(x => x.StepNo == SelectedParameterStep.StepNo - 1).FirstOrDefault());
            }
        }

        public void InsertPrevStep()
        {

        }

        public void InsertCopyStep()
        {
            var windowManager = IoC.Get<IWindowManager>();
            if (CurrentParameter == null) return;

        }

        public void SetHeaterTempIsCheck(string cmdType, object obj)
        {
            if (obj != null && obj is AlarmConditionHeaterTemp)
            {
                var tempHeater = (AlarmConditionHeaterTemp)obj;
                switch (cmdType)
                {
                    case "Alert":
                        tempHeater.AlertTempData.IsCheck = !tempHeater.AlertTempData.IsCheck;
                        break;
                    case "Alarm":
                        tempHeater.AlarmTempData.IsCheck = !tempHeater.AlarmTempData.IsCheck;
                        break;
                    default:
                        break;
                }
            }
        }

        public void SetTempBoatIsCheck(object obj)
        {
            if (obj != null && obj is AlarmConditionBoatTemp)
            {
                var boatTemp = (AlarmConditionBoatTemp)obj;
                boatTemp.IsCheck = !boatTemp.IsCheck;
            }
        }

        public void SetMFCIsCheck(string cmdType, object obj)
        {
            if (obj != null)
                if (obj is AlarmConditionMFCFlowDeviation)
                {
                    var flowDeviation = (AlarmConditionMFCFlowDeviation)obj;
                    switch (cmdType)
                    {
                        case "Alert":
                            flowDeviation.AlertTempData.IsCheck = !flowDeviation.AlertTempData.IsCheck;
                            break;
                        case "Alarm":
                            flowDeviation.AlarmTempData.IsCheck = !flowDeviation.AlarmTempData.IsCheck;
                            break;
                        default:
                            break;
                    }
                }
                else if (obj is AlarmConditionMFCOther)
                {
                    var mFCOther = (AlarmConditionMFCOther)obj;
                    //switch (cmdType)
                    //{
                    //    case "Alert":
                    //        mFCOther.AlertTempData.IsCheck = !mFCOther.AlertTempData.IsCheck;
                    //        break;
                    //    case "Alarm":
                    //        mFCOther.AlarmTempData.IsCheck = !mFCOther.AlarmTempData.IsCheck;
                    //        break;
                    //    default:
                    //        break;
                    //}
                }
        }

        public void SetPressIsCheck(string cmdType, object obj)
        {
            if (obj != null && obj is AlarmConditionPress)
            {
                var tempHeater = (AlarmConditionPress)obj;
                switch (cmdType)
                {
                    case "Alert":
                        tempHeater.AlertTempData.IsCheck = !tempHeater.AlertTempData.IsCheck;
                        break;
                    case "Alarm":
                        tempHeater.AlarmTempData.IsCheck = !tempHeater.AlarmTempData.IsCheck;
                        break;
                    default:
                        break;
                }
            }
        }

        public void SetAUXIsCheck(string cmdType, object obj)
        {
            if (obj != null && obj is AlarmConditionAUX)
            {
                var tempHeater = (AlarmConditionAUX)obj;
                switch (cmdType)
                {
                    case "Alert":
                        tempHeater.AlertTempData.IsCheck = !tempHeater.AlertTempData.IsCheck;
                        break;
                    case "Alarm":
                        tempHeater.AlarmTempData.IsCheck = !tempHeater.AlarmTempData.IsCheck;
                        break;
                    default:
                        break;
                }
            }
        }

        public void SetHWILKIsCheck(object obj)
        {
            if (obj != null && obj is AlarmConditionHWILK)
            {
                var hWILK = (AlarmConditionHWILK)obj;
                hWILK.IsCheck = !hWILK.IsCheck;
            }
        }

        public void SetHardSoftIsCheck(object obj)
        {
            if (obj != null)
                if (obj is AlarmConditionValveILK)
                {
                    var valveILK = (AlarmConditionValveILK)obj;
                    valveILK.IsCheck = !valveILK.IsCheck;
                }
                else if (obj is AlarmConditionTempControler)
                {
                    var tempControler = (AlarmConditionTempControler)obj;
                    tempControler.IsCheck = !tempControler.IsCheck;
                }
                else if (obj is AlarmConditionAPCControler)
                {
                    var aPCControler = (AlarmConditionAPCControler)obj;
                    aPCControler.IsCheck = !aPCControler.IsCheck;
                }
                else if (obj is AlarmConditionTransferError)
                {
                    var transferError = (AlarmConditionTransferError)obj;
                    transferError.IsCheck = !transferError.IsCheck;
                }
                else if (obj is AlarmConditionCLNAlarm)
                {
                    var alarmConditionCLNError = (AlarmConditionCLNAlarm)obj;
                    alarmConditionCLNError.IsCheck = !alarmConditionCLNError.IsCheck;
                }
        }

        public void SetContDownIsCheck(object obj)
        {
            if (obj != null)
            {
                if (obj is AlarmConditionSerialLineDown)
                {
                    var serialLineDown = (AlarmConditionSerialLineDown)obj;
                    serialLineDown.IsCheck = !serialLineDown.IsCheck;
                }
                else if (obj is AlarmConditionLanLineDown)
                {
                    var lanLineDown = (AlarmConditionLanLineDown)obj;
                    lanLineDown.IsCheck = !lanLineDown.IsCheck;
                }
                else if (obj is AlarmConditionDeviceNetLineDown)
                {
                    var deviceNetLineDown = (AlarmConditionDeviceNetLineDown)obj;
                    deviceNetLineDown.IsCheck = !deviceNetLineDown.IsCheck;
                }
            }
        }

        public void SetSensorIsCheck(string cmdType, object obj)
        {
            if (obj != null && obj is AlarmConditionSensor)
            {
                var sensor = (AlarmConditionSensor)obj;
                switch (cmdType)
                {
                    case "Alert":
                        sensor.AlertTempData.IsCheck = !sensor.AlertTempData.IsCheck;
                        break;
                    case "Alarm":
                        sensor.AlarmTempData.IsCheck = !sensor.AlarmTempData.IsCheck;
                        break;
                    default:
                        break;
                }
            }
        }

        public void SetOtherIsCheck(object obj)
        {
            if (obj != null && obj is AlarmConditionOther)
            {
                var other = (AlarmConditionOther)obj;
                other.IsCheck = !other.IsCheck;
            }
        }

        //public void TempSetClick(object sender)
        //{
        //    string stSetValue = ShowNumberKeyboard(sender as Button, "");
        //}

        //public void RampSetClick(object sender)
        //{
        //    string strSetRamp = ShowNumberKeyboard(sender as Button, "");
        //}

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

        public void TempTextClick(string type, object sender)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch (type)
            {
                case "Mode":
                    RecipeTempModeViewModel recipeTempModeViewModel = new RecipeTempModeViewModel();
                    var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(recipeTempModeViewModel, null, "Temp Mode");
                    break;
                case "Correct":
                    TempOffsetTableViewModel tempOffsetTableViewModel = new TempOffsetTableViewModel();
                    break;
                case "PID":
                    TempOffsetTableViewModel tempOffsetTableViewModel1 = new TempOffsetTableViewModel();
                    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 = SelectedParameterStep.StepNo;
                var step = CurrentParameter.Steps.Where(x => x.StepNo == stepNo).FirstOrDefault();
            }
        }

        public void ParameterEdit(object cmdName, object value)
        {
            var windowManager = IoC.Get<IWindowManager>();
            switch ((string)cmdName)
            {
                case "RecipeName":

                    break;
                case "StepName":

                    break;
                default:
                    break;
            }
        }
        private RecipeProvider _recipeProvider = new RecipeProvider();

        public void SelectCommandType(string cmdType)
        {
            switch (cmdType)
            {
                default:
                    break;
            }
        }

        public void SelectedParameterCommand(string cmdType, string name, object obj)
        {
            if (obj is TextBox)
            {

                var txtEx = (TextBox)obj;
                ParameterCommandViewModel parameterCommandViewModel = new ParameterCommandViewModel();
                var windowManager = IoC.Get<IWindowManager>();
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
                if ((bool)rtn)
                {
                    var step = SelectedParameterStep.HeaterTempList.Where(x => x.ZoneName == name).FirstOrDefault();
                    switch (cmdType)
                    {
                        case "Alert":
                            step.AlertTempData.ErrorCommand = parameterCommandViewModel.SelectCommand;
                            break;
                        case "Alarm":
                            step.AlarmTempData.ErrorCommand = parameterCommandViewModel.SelectCommand;
                            break;
                        default:
                            break;
                    }
                }
            }
        }
        public void SelectedAlarmErrorParameterCommand(string cmdType, string name, object obj)
        {
            if (obj is TextBox)
            {



                var txtEx = (TextBox)obj;
                AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
                parameterCommandViewModel.SelectCommand = txtEx.Text;
                parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
                var windowManager = IoC.Get<IWindowManager>();
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
                if ((bool)rtn)
                {
                    ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                    SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;
                    var step = SelectedParameterStep.HeaterTempList.Where(x => x.ZoneName == name).FirstOrDefault();
                    switch (cmdType)
                    {
                        case "Alert":
                            step.AlertTempData.ErrorCommand = SelectCommandName;
                            break;
                        case "Alarm":
                            step.AlarmTempData.ErrorCommand = SelectCommandName;
                            break;
                        default:
                            break;
                    }
                }
            }
        }
        public void SelectedMFCFlowCommand(string cmdType, string name, object obj)
        {
            if (obj is TextBox)
            {
                var txtEx = (TextBox)obj;
                AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
                parameterCommandViewModel.SelectCommand = txtEx.Text;
                parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
                var windowManager = IoC.Get<IWindowManager>();
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
                if ((bool)rtn)
                {
                    ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                    SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                    var mFCFlowDeviation = SelectedParameterStep.MFCFlowDeviationList.Where(x => x.MFCName == name).FirstOrDefault();
                    switch (cmdType)
                    {
                        case "Alert":
                            mFCFlowDeviation.AlertTempData.ErrorCommand = SelectCommandName;
                            break;
                        case "Alarm":
                            mFCFlowDeviation.AlarmTempData.ErrorCommand = SelectCommandName;
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        public void SelectedPressCommand(string cmdType, string name, object obj)
        {
            if (obj is TextBox)
            {
                var txtEx = (TextBox)obj;
                AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
                parameterCommandViewModel.SelectCommand = txtEx.Text;
                parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
                var windowManager = IoC.Get<IWindowManager>();
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
                if ((bool)rtn)
                {
                    ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                    SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                    var press = SelectedParameterStep.PressList.Where(x => x.PressKindName == name).FirstOrDefault();
                    switch (cmdType)
                    {
                        case "Alert":
                            press.AlertTempData.ErrorCommand = SelectCommandName;
                            break;
                        case "Alarm":
                            press.AlarmTempData.ErrorCommand = SelectCommandName;
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        public void SelectedAUXCommand(string cmdType, string name, object obj)
        {
            if (obj is TextBox)
            {
                var txtEx = (TextBox)obj;
                AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
                parameterCommandViewModel.SelectCommand = txtEx.Text;
                parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
                var windowManager = IoC.Get<IWindowManager>();
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
                if ((bool)rtn)
                {
                    ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                    SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                    var aux = SelectedParameterStep.AUXList.Where(x => x.AUXName == name).FirstOrDefault();
                    switch (cmdType)
                    {
                        case "Alert":
                            aux.AlertTempData.ErrorCommand = SelectCommandName;
                            break;
                        case "Alarm":
                            aux.AlarmTempData.ErrorCommand = SelectCommandName;
                            break;
                        default:
                            break;
                    }
                }
            }
        }


        public void SelectedHWILKCommand(object obj, object txtObj)
        {
            var txtEx = (TextBox)txtObj;
            AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
            parameterCommandViewModel.SelectCommand = txtEx.Text;
            parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
            var windowManager = IoC.Get<IWindowManager>();
            var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
            if ((bool)rtn)
            {
                ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                if (obj is AlarmConditionHWILK)
                {
                    ((AlarmConditionHWILK)obj).ErrorCommand = SelectCommandName;
                }
            }
        }

        public void SelectedHardSoftCommand(object obj, object txtObj)
        {
            var txtEx = (TextBox)txtObj;
            AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
            parameterCommandViewModel.SelectCommand = txtEx.Text;
            parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
            var windowManager = IoC.Get<IWindowManager>();
            var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
            if ((bool)rtn)
            {
                ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                if (obj is AlarmConditionValveILK)
                {
                    ((AlarmConditionValveILK)obj).ErrorCommand = SelectCommandName;
                }
                else if (obj is AlarmConditionTempControler)
                {
                    ((AlarmConditionTempControler)obj).ErrorCommand = SelectCommandName;
                }
                else if (obj is AlarmConditionAPCControler)
                {
                    ((AlarmConditionAPCControler)obj).ErrorCommand = SelectCommandName;
                }
                else if (obj is AlarmConditionCLNAlarm)
                {
                    ((AlarmConditionCLNAlarm)obj).ErrorCommand = SelectCommandName;
                }
                else if (obj is AlarmConditionTransferError)
                {
                    ((AlarmConditionTransferError)obj).ErrorCommand = SelectCommandName;
                }
            }
        }

        public void SelectedContDownCommand(object obj, object txtObj)
        {
            var txtEx = (TextBox)txtObj;
            AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
            parameterCommandViewModel.SelectCommand = txtEx.Text;
            parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
            var windowManager = IoC.Get<IWindowManager>();
            var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
            if ((bool)rtn)
            {
                ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                if (obj is AlarmConditionSerialLineDown)
                {
                    ((AlarmConditionSerialLineDown)obj).ErrorCommand = SelectCommandName;
                }
                else if (obj is AlarmConditionLanLineDown)
                {
                    ((AlarmConditionLanLineDown)obj).ErrorCommand = SelectCommandName;
                }
                else if (obj is AlarmConditionDeviceNetLineDown)
                {
                    ((AlarmConditionDeviceNetLineDown)obj).ErrorCommand = SelectCommandName;
                }
            }
        }

        public void SelectedSensorCommand(string cmdType, string name, object obj)
        {
            if (obj is TextBox)
            {
                var txtEx = (TextBox)obj;
                AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
                parameterCommandViewModel.SelectCommand = txtEx.Text;
                parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
                var windowManager = IoC.Get<IWindowManager>();
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
                if ((bool)rtn)
                {
                    ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                    SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                    var sensor = SelectedParameterStep.SensorList.FirstOrDefault(x => x.SensorName == name);
                    switch (cmdType)
                    {
                        case "Alert":
                            sensor.AlertTempData.ErrorCommand = SelectCommandName;
                            break;
                        case "Alarm":
                            sensor.AlarmTempData.ErrorCommand = SelectCommandName;
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        public void SelectedOtherCommand(object obj, object txtObj)
        {
            var txtEx = (TextBox)txtObj;
            AlarmErrorCommandViewModel parameterCommandViewModel = new AlarmErrorCommandViewModel();
            parameterCommandViewModel.SelectCommand = txtEx.Text;
            parameterCommandViewModel.ResultParameterStr = ResultParameterStr;
            var windowManager = IoC.Get<IWindowManager>();
            var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(parameterCommandViewModel, null, "Command");
            if ((bool)rtn)
            {
                ResultParameterStr = parameterCommandViewModel.ResultParameterStr;

                SelectCommandName = ResultParameterStr != null ? $"{parameterCommandViewModel.SelectCommand} {ResultParameterStr}" : parameterCommandViewModel.SelectCommand;

                if (obj is AlarmConditionOther)
                {
                    ((AlarmConditionOther)obj).ErrorCommand = SelectCommandName;
                }
            }
        }


        public void ParameterSave()
        {
            var SelectedStep = this.CurrentParameter.Steps.Where(x => x.StepNo == SelectedStepNo).FirstOrDefault();
            //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;
            if (IsEnableEdit)
            {
                List<string> names = new List<string>();
                string filmFormula = string.Empty;
                ParameterTable step = CurrentParameter.Steps.Where(x => x.StepNo == SelectedParameterStep.StepNo).FirstOrDefault();
                this.CurrentParameter.Revisor = BaseApp.Instance.UserContext.LoginName;
                this.CurrentParameter.ReviseTime = DateTime.Now;
                this.CurrentParameter.Level = this.LevelDisplay;
                //this.CurrentRecipe.RecipePermission = dialog.RecipePermission;
                // APC PressureUnit
                if (CurrentParameter != null)
                {
                    string aUXUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.AUXAlarmCondtionUnit");
                    if (aUXUnit != null)
                    {
                        CurrentParameter.Steps.ToList().ForEach(x => ((AlarmConditionTable)x).AUXList.ToList().ForEach(s =>
                        {
                            s.AlertTempData.Unit = aUXUnit;
                            s.AlarmTempData.Unit = aUXUnit;
                        }));
                    }
                    string mFCUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.MFCAlarmCondtionUnit");
                    if (mFCUnit != null)
                    {
                        CurrentParameter.Steps.ToList().ForEach(x => ((AlarmConditionTable)x).MFCFlowDeviationList.ToList().ForEach(s =>
                        {
                            s.AlertTempData.Unit = aUXUnit;
                            s.AlarmTempData.Unit = aUXUnit;
                        }));
                    }
                    string pressUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.APC.PressureUnit");
                    string angleUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.APC.AngleAlarmCondtionUnit");
                    if (!string.IsNullOrEmpty(pressUnit) && !string.IsNullOrEmpty(angleUnit))
                    {
                        CurrentParameter.Steps.ToList().ForEach(x => ((AlarmConditionTable)x).PressList.ToList().ForEach(s =>
                        {
                            if (s.PressKindName == "APC Angle")
                            {
                                s.AlertTempData.Unit = angleUnit;
                                s.AlarmTempData.Unit = angleUnit;
                            }
                            else
                            {
                                s.AlertTempData.Unit = pressUnit;
                                s.AlarmTempData.Unit = pressUnit;
                            }
                        }));
                    }
                }
                var result = this._parameterProvider.SaveParameter(CurrentParameter.PrefixPath, CurrentParameter.Name, CurrentParameter.GetXmlString());
                if (result)
                    ((Window)GetView()).Close();
            }
            else
            {

                if (SelectedStepNo > 0)
                {
                    if (string.IsNullOrEmpty(CurrentParameter.Name))
                    {
                        ReturnString = $"{SelectedStepNo}:";
                    }
                    else
                    {
                        ReturnString = $"{SelectedStepNo}:{SelectedStepName}";
                    }
                }
                this.TryClose(true);
            }
        }

        public void ParameterDownload()
        {
            if (NewPM1EntityStatus.ToLower() != "idle")
            {
                DialogBox.ShowDialog(DialogButton.Yes, DialogType.INFO, " The device is not in the idle state!");
                return;
            }
            var step = CurrentParameter.Steps.FirstOrDefault(x => x.IsChecked);
            InvokeClient.Instance.Service.DoOperation($"PM1.SetAlarmConditionParameter", $"{CurrentParameter.Name}", step.StepNo);
        }

        public void ParameterUnload()
        {

        }

        public void ParameterCopy()
        {
            if (SelectedParameterStep != null)
            {
                CopyParameterStep = (AlarmConditionTable)CloneUtil.CloneObject(SelectedParameterStep);
                IsCopyEnabled = true;
            }
        }

        public void ParameterPaste()
        {
            var tempStepNo = SelectedParameterStep.StepNo;
            var getStep = CurrentParameter.Steps.ToList().FirstOrDefault(x => x.StepNo == SelectedParameterStep.StepNo);
            getStep = (ParameterTable)CloneUtil.CloneObject(CopyParameterStep);
            getStep.StepNo = tempStepNo;
            var instIndex = 0;
            if (SelectedParameterStep.StepNo > 0) instIndex = SelectedParameterStep.StepNo - 1;
            CurrentParameter.Steps.RemoveAt(instIndex);
            CurrentParameter.Steps.Insert(instIndex, getStep);
            SelectedParameterStep = (AlarmConditionTable)getStep;
            RdoCmdSelectTypeChecked(RdoStringType);
            SetCmdIsEnabled();
        }

        public void ParameterCancel()
        {
            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();
        }

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

        private void SetTubeStatus()
        {
            if (SecondPjList != null && SecondPjList.Count > 0 && SecondPjList.FirstOrDefault() != null && ControlJobs != null && ControlJobs.Count > 0)
            {
                var secondPj = SecondPjList.FirstOrDefault();
                var actualPjName = ControlJobs.FirstOrDefault().ProcessJobNameList.FirstOrDefault();
                if (secondPj.Name.Equals(actualPjName) && (int)secondPj.ProcessingState <= (int)EnumProcessingState.Processing)
                {
                    NewPM1EntityStatus = "Process";
                }
                else
                {
                    NewPM1EntityStatus = PM1EntityStatus;
                }
            }
            else
            {
                NewPM1EntityStatus = PM1EntityStatus;
            }

        }

        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 RdoCmdSelectTypeChecked(string cmd)
        {
            RdoStringType = cmd;
            switch (cmd)
            {
                case "Temp":
                    SetShowGrid(AlarmConditionCmdType.Temp);
                    break;
                case "MFC":
                    SetShowGrid(AlarmConditionCmdType.MFC);
                    break;
                case "Press":
                    SetShowGrid(AlarmConditionCmdType.Press);
                    break;
                case "AUX":
                    SetShowGrid(AlarmConditionCmdType.AUX);
                    break;
                case "HWILK":
                    SetShowGrid(AlarmConditionCmdType.HWILK);
                    break;
                case "HardSoft":
                    SetShowGrid(AlarmConditionCmdType.HardSoft);
                    break;
                case "ContDown":
                    SetShowGrid(AlarmConditionCmdType.ContDown);
                    break;
                case "Sensor":
                    SetShowGrid(AlarmConditionCmdType.Sensor);
                    break;
                case "Other":
                    SetShowGrid(AlarmConditionCmdType.Other);
                    break;
                default:
                    break;
            }
        }



        public void RdoCmdSelectTempChecked(string cmd)
        {
            TempStringType = cmd;
            switch (cmd)
            {
                case "Heater":
                    TempMainHeaterVisibility = Visibility.Visible;
                    CurrentHeaterTempList.Clear();
                    _selectedParameterStep.HeaterTempList.ToList().ForEach(x => CurrentHeaterTempList.Add(x));
                    TempBoatVisibility = Visibility.Hidden;
                    break;
                case "Boat":
                    TempMainHeaterVisibility = Visibility.Hidden;
                    TempBoatVisibility = Visibility.Visible;
                    CurrentBoatTempList.Clear();
                    _selectedParameterStep.BoatTempList.ToList().ForEach(x => CurrentBoatTempList.Add(x));
                    break;
                default:
                    break;
            }
        }

        public void RdoCmdSelectMFCChecked(string cmd)
        {
            var alarmConditionView = ((AlarmConditionEditView)((Window)GetView()).Content);
            MFCStringType = cmd;
            if (SelectedParameterStep == null) return;
            switch (cmd)
            {
                case "Flow":
                    CurrentMFCDeviationList.Clear();
                    string mFCUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.MFCAlarmCondtionUnit");
                    if (mFCUnit != null)
                    {
                        SelectedParameterStep.MFCFlowDeviationList.ToList().ForEach(s =>
                        {
                            s.AlertTempData.Unit = mFCUnit;
                            s.AlarmTempData.Unit = mFCUnit;
                        });
                    }
                    SelectedParameterStep.MFCFlowDeviationList.ToList().ForEach(x => CurrentMFCDeviationList.Add(x));
                    break;
                case "Other":
                    CurrentMFCDeviationList.Clear();
                    SelectedParameterStep.MFCOtherList.ToList().ForEach(x => CurrentMFCDeviationList.Add(x));
                    break;
                default:
                    break;
            }
        }


        public void RdoCmdSelectHardSoftChecked(string cmd)
        {
            var alarmConditionView = ((AlarmConditionEditView)((Window)GetView()).Content);
            if (SelectedParameterStep == null) return;
            switch (cmd)
            {
                case "Valve":
                    CurrentHardSoftList.Clear();
                    SelectedParameterStep.ValveIlkList.ToList().ForEach(x => CurrentHardSoftList.Add(x));
                    break;
                case "Temp":
                    CurrentHardSoftList.Clear();
                    SelectedParameterStep.TempControlerList.ToList().ForEach(x => CurrentHardSoftList.Add(x));
                    break;
                case "APC":
                    CurrentHardSoftList.Clear();
                    SelectedParameterStep.APCControlerList.ToList().ForEach(x => CurrentHardSoftList.Add(x));
                    break;
                case "Transfer":
                    CurrentHardSoftList.Clear();
                    SelectedParameterStep.TransferErrorList.ToList().ForEach(x => CurrentHardSoftList.Add(x));
                    break;
                case "CLNAlarm":
                    CurrentHardSoftList.Clear();
                    SelectedParameterStep.CLNAlarmList.ToList().ForEach(x => CurrentHardSoftList.Add(x));
                    break;
                default:
                    break;
            }
        }

        public void RdoCmdSelectContDownChecked(string cmd)
        {
            var alarmConditionView = ((AlarmConditionEditView)((Window)GetView()).Content);
            if (SelectedParameterStep == null) return;
            switch (cmd)
            {
                case "SerialLineDown":
                    CurrentContDownList.Clear();
                    SelectedParameterStep.SerialLineDownList.ToList().ForEach(x => CurrentContDownList.Add(x));
                    break;
                case "LanLineDown":
                    CurrentContDownList.Clear();
                    SelectedParameterStep.LanLineDownList.ToList().ForEach(x => CurrentContDownList.Add(x));
                    break;
                //case "DeviceNetLineDown":
                //    alarmConditionView.ContDownLV.ItemsSource = SelectedParameterStep.DeviceNetLineDownList;
                //    break;
                default:
                    break;
            }
        }

        public void SetShowGrid(AlarmConditionCmdType cmdType)
        {
            switch (cmdType)
            {
                case AlarmConditionCmdType.Temp:
                    TempVisibility = Visibility.Visible;
                    if (TempStringType == "Heater")
                    {
                        CurrentHeaterTempList.Clear();
                        _selectedParameterStep.HeaterTempList.ToList().ForEach(x => CurrentHeaterTempList.Add(x));
                    }
                    else if (TempStringType == "Boat")
                    {
                        CurrentBoatTempList.Clear();
                        _selectedParameterStep.BoatTempList.ToList().ForEach(x => CurrentBoatTempList.Add(x));
                    }
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.MFC:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Visible;
                    switch (MFCStringType)
                    {
                        case "Flow":
                            CurrentMFCDeviationList.Clear();
                            string mFCUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.MFCAlarmCondtionUnit");
                            if (mFCUnit != null)
                            {
                                SelectedParameterStep.MFCFlowDeviationList.ToList().ForEach(s =>
                                {
                                    s.AlertTempData.Unit = mFCUnit;
                                    s.AlarmTempData.Unit = mFCUnit;
                                });
                            }
                            SelectedParameterStep.MFCFlowDeviationList.ToList().ForEach(x => CurrentMFCDeviationList.Add(x));
                            break;
                        case "Other":
                            CurrentMFCDeviationList.Clear();
                            SelectedParameterStep.MFCOtherList.ToList().ForEach(x => CurrentMFCDeviationList.Add(x));
                            break;
                        default:
                            break;
                    }
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.Press:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Visible;
                    CurrentPressList.Clear();
                    SelectedParameterStep.PressList.ToList().ForEach(x => CurrentPressList.Add(x));
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.AUX:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Visible;
                    string aUXUnit = (string)QueryDataClient.Instance.Service.GetConfig("PM1.AUXAlarmCondtionUnit");
                    if (aUXUnit != null)
                    {
                        SelectedParameterStep.AUXList.ToList().ForEach(s =>
                        {
                            s.AlertTempData.Unit = aUXUnit;
                            s.AlarmTempData.Unit = aUXUnit;
                        });
                    }
                    CurrentAUXList.Clear();
                    SelectedParameterStep.AUXList.ToList().ForEach(x => CurrentAUXList.Add(x));
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.HWILK:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Visible;
                    CurrentHWILKList.Clear();
                    SelectedParameterStep.HWILKList.ToList().ForEach(x => CurrentHWILKList.Add(x));
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.HardSoft:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Visible;

                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.ContDown:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Visible;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.Sensor:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Visible;
                    OtherVisibility = Visibility.Hidden;
                    break;
                case AlarmConditionCmdType.Other:
                    TempVisibility = Visibility.Hidden;
                    MFCVisibility = Visibility.Hidden;
                    PressVisibility = Visibility.Hidden;
                    AUXVisibility = Visibility.Hidden;
                    HWILKVisibility = Visibility.Hidden;
                    HardSoftVisibility = Visibility.Hidden;
                    ContDownVisibility = Visibility.Hidden;
                    SensorVisibility = Visibility.Hidden;
                    OtherVisibility = Visibility.Visible;
                    break;
                default:
                    break;
            }


        }


        public void AlarmTempDataUnitClick(TempData tempData)
        {
            TempData temp = tempData;


        }
    }


    public enum AlarmConditionCmdType
    {
        Temp,
        MFC,
        Press,
        AUX,
        HWILK,
        HardSoft,
        ContDown,
        Sensor,
        Other
    }
}