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

using Aitex.Core.RT.SCCore;
using Caliburn.Micro;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using OpenSEMI.ClientBase;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using FurnaceUI.Models;

namespace FurnaceUI.Views.Editors
{
    public class RecipeRFAlarmTableSettingViewModel: FurnaceUIViewModelBase
    {
        public string SelectAlarmWatchTable { get; set; } = "None";

        public bool IsSave { get; set; } = false;

        private string _selectC1AlarmValue = "0";
        public string SelectC1AlarmValue
        {
            get
            {
                return _selectC1AlarmValue;
            }
            set
            {
                _selectC1AlarmValue = value;
                NotifyOfPropertyChange("SelectC1AlarmValue");
            }
        }

        private string _selectC2AlarmValue = "0";
        public string SelectC2AlarmValue
        {
            get
            {
                return _selectC2AlarmValue;
            }
            set
            {
                _selectC2AlarmValue = value;
                NotifyOfPropertyChange("SelectC2AlarmValue");
            }
        }

        private string _selectForwardPowerValue = "0";
        public string SelectForwardPowerValue
        {
            get
            {
                return _selectForwardPowerValue;
            }
            set
            {
                _selectForwardPowerValue = value;
                NotifyOfPropertyChange("SelectForwardPowerValue");
            }
        }

        private string _selectPrAlarmWatchValue = "0";
        public string SelectPrAlarmWatchValue
        {
            get
            {
                return _selectPrAlarmWatchValue;
            }
            set
            {
                _selectPrAlarmWatchValue = value;
                NotifyOfPropertyChange("SelectPrAlarmWatchValue");
            }
        }

        private string _selectPIAlarmWatchValue = "0";
        public string SelectPIAlarmWatchValue
        {
            get
            {
                return _selectPIAlarmWatchValue;
            }
            set
            {
                _selectPIAlarmWatchValue = value;
                NotifyOfPropertyChange("SelectPIAlarmWatchValue");
            }
        }


        private string _selectVppAlarmWatchValue = "0";
        public string SelectVppAlarmWatchValue
        {
            get
            {
                return _selectVppAlarmWatchValue;
            }
            set
            {
                _selectVppAlarmWatchValue = value;
                NotifyOfPropertyChange("SelectVppAlarmWatchValue");
            }
        }

        private string _selectVdcAlarmWatchValue = "0";
        public string SelectVdcAlarmWatchValue
        {
            get
            {
                return _selectVdcAlarmWatchValue;
            }
            set
            {
                _selectVdcAlarmWatchValue = value;
                NotifyOfPropertyChange("SelectVdcAlarmWatchValue");
            }
        }

        private ConfigNode levelOneNode;

        public ConfigNode LevelOneNode
        {
            get { return levelOneNode; }
            set { levelOneNode = value; this.NotifyOfPropertyChange(nameof(LevelOneNode)); }
        }
        private ConfigNode levelTwoNode;

        public ConfigNode LevelTwoNode
        {
            get { return levelTwoNode; }
            set { levelTwoNode = value; this.NotifyOfPropertyChange(nameof(LevelTwoNode)); }
        }
        private List<ConfigItem> currenItems;

        public List<ConfigItem> CurrenItems
        {
            get { return currenItems; }
            set { currenItems = value; this.NotifyOfPropertyChange(nameof(CurrenItems)); }
        }
        private string _CurrentNodeName = string.Empty;
        private ConfigNode _rootNode;
        public bool IsEnable => CGlobal.RecipeProcessEditViewEnable;//是否是View模式
        public bool IsAlarmNoneChecked { get; set; }

        public Visibility isForbid;
        public Visibility IsForbid
        {
            get { return isForbid; }
            set { isForbid = value; this.NotifyOfPropertyChange(nameof(IsForbid)); }
        }

        public bool isAvailabled;
        public bool IsAvailabled
        {
            get { return isAvailabled; }
            set { isAvailabled = value; this.NotifyOfPropertyChange(nameof(IsAvailabled)); }
        }

        public string SetPointName { get; set; }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            IsAlarmNoneChecked = SelectAlarmWatchTable == "None";
            _rootNode = SystemConfigProvider.Instance.GetConfig(true);
            LevelOneNode = new ConfigNode();
            LevelOneNode = FindNodeByName(_rootNode, $"PM1.RecipeEditParameter.AlarmWatchTable.RFAlarmWatchTable.{SetPointName}");
            LevelTwoNode = LevelOneNode.SubNodes.FirstOrDefault();
            IsForbid = Visibility.Visible;
            if (SelectAlarmWatchTable != "None")
            {
                LevelOneNode.SubNodes[int.Parse(SelectAlarmWatchTable) - 1].AlarmWatchBoolValue = true;
            }
            InitItemsCurrentValue(LevelTwoNode, true);
        }

        private void InitItemsCurrentValue(ConfigNode node, bool initSubItems = true)
        {
            if (node == null) return;
            CurrenItems = node.Items;
            _CurrentNodeName = string.IsNullOrEmpty(node.Path) ? node.Name : $"{node.Path}.{"Table" + SelectAlarmWatchTable}";
            if (CurrenItems == null || CurrenItems.Count <= 0)
            {
                if (!initSubItems) return;
                foreach (var item in node.SubNodes)
                {
                    InitItemsCurrentValue(item);
                }
            }
            else
            {
                GetDataOfConfigItems();
            }
        }
        private void GetDataOfConfigItems()
        {
            if (CurrenItems == null)
                return;

            for (int i = 0; i < CurrenItems.Count; i++)
            {
                string key = String.Format("{0}{1}{2}", _CurrentNodeName, ".", CurrenItems[i].Name);
                CurrenItems[i].CurrentValue = SystemConfigProvider.Instance.GetValueByName(key);
                CurrenItems[i].Path = key;
                CurrenItems[i].StringValue = CurrenItems[i].CurrentValue;
            }
        }
        public void MenuCommand(object obj, object menuLevel)
        {
            RadioButton radioButton = obj as RadioButton;
            ConfigNode currentNode = null;
            switch (SetPointName)
            {
                case "C1AlarmWatch":
                    SelectC1AlarmValue = radioButton.Content.ToString();
                    break;
                case "VppAlarmWatch":
                    SelectVppAlarmWatchValue = radioButton.Content.ToString();
                    break;
                case "ForwardPowerAlarmWatch":
                    SelectForwardPowerValue = radioButton.Content.ToString();
                    break;
                case "PrAlarmWatch":
                    SelectPrAlarmWatchValue = radioButton.Content.ToString();
                    break;
                case "PIAlarmWatch":
                    SelectPIAlarmWatchValue = radioButton.Content.ToString();
                    break;
                case "C2AlarmWatch":
                    SelectC2AlarmValue = radioButton.Content.ToString();
                    break;
                case "VdcAlarmWatch":
                    SelectVdcAlarmWatchValue = radioButton.Content.ToString();
                    break;
            }
            SelectAlarmWatchTable = radioButton.Content.ToString();
            IsForbid = Visibility.Visible;
            IsAvailabled = true;
            IsAlarmNoneChecked = false;
            if (radioButton.Content.ToString() == "None")
            {
                IsForbid = Visibility.Hidden;
                IsAvailabled = false;
                return;
            }
            switch (menuLevel.ToString())
            {
                case "LevelOne":
                    currentNode = LevelTwoNode = LevelOneNode.SubNodes.Find((x) => x.Name == radioButton.ToolTip.ToString());
                    break;

            }
            InitItemsCurrentValue(currentNode);
        }
        public void SetValue(object obj)
        {
            if (CurrenItems == null || currenItems.Count == 0) return;
            ConfigItem item = null;
            if (obj is Control)
                item = CurrenItems.Find((x) => x.Name == (obj as Control).ToolTip.ToString());
            else
                item = obj as ConfigItem;
            InputDialogViewModel dialog = new InputDialogViewModel();
            dialog.Item = item;
            dialog.DisplayName = "Set Value";
            WindowManager wm = new WindowManager();
            bool? bret = wm.ShowDialog(dialog);
            if ((bool)bret)
            {
                item.StringValue = dialog.DialogResult;

                string value;
                if (item.Type == DataType.Int)
                {
                    int iValue;
                    if (int.TryParse(item.StringValue, out iValue))
                    {
                        if (!double.IsNaN(item.Max) && !double.IsNaN(item.Min))
                        {
                            if (iValue > item.Max || iValue < item.Min)
                            {
                                DialogBox.ShowWarning(string.Format("The value should be between {0}  and {1}.", ((int)item.Min).ToString(), ((int)item.Max).ToString()));
                                return;
                            }
                        }
                    }
                    else
                    {
                        DialogBox.ShowWarning("Please input valid data.");
                        return;
                    }
                    value = item.StringValue;
                }
                value = item.StringValue;

                string key = String.Format("{0}{1}{2}", _CurrentNodeName, ".", item.Name);
                InvokeClient.Instance.Service.DoOperation("System.SetConfig", item.Path, value);

            }
        }

        private ConfigNode FindNodeByName(ConfigNode parentNode, string strName)
        {
            var strCates = strName.Split('.');
            ConfigNode node = parentNode.SubNodes.Find((x) => x.Name == strCates[0]);
            if (node == null)
                return parentNode;
            else
            {
                string strNewName = string.Empty;
                for (int i = 1; i < strCates.Length; i++)
                {
                    strNewName = $"{strNewName}.{strCates[i]}";
                }
                strNewName=strNewName.Trim('.');
                return FindNodeByName(node, strNewName);
            }
                
        }

        public void SaveCmd()
        {
            IsSave = true;
            ((Window)GetView()).DialogResult = true;
        }

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