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

using Aitex.Core.RT.SCCore;
using Caliburn.Micro;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using MECF.Framework.UI.Client.CenterViews.Dialogs;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using OpenSEMI.ClientBase;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
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;
using FurnaceUI.Views.Editors;
using FurnaceUI.Views.Recipes;

namespace FurnaceUI.Views.Parameter
{
    public class MainParameterEditViewModel : FurnaceUIViewModelBase
    {
        public List<ParamBase> ParameterTree { get; set; } = new List<ParamBase>();
        public RecipeDataBase CurrentRecipe { get; set; } = new RecipeDataBase();
        public bool IsPermission { get => this.Permission == 3; }
        public ObservableCollection<TempSetData> HeadLst { get; set; } = new ObservableCollection<TempSetData>();

        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 List<ConfigNode> _ConfigNodes = new List<ConfigNode>();

        public List<ConfigNode> ConfigNodes
        {
            get { return _ConfigNodes; }
            set { _ConfigNodes = value; NotifyOfPropertyChange("ConfigNodes"); }
        }
        private string _defaultUnit = "Pa";
        public string DefaultUnit
        {
            get
            {

                return _defaultUnit;
            }
            set
            {
                _defaultUnit = value;
                NotifyOfPropertyChange("DefaultUnit");
            }
        }
        private ConfigNode _rootNode;
        private string _CurrentNodeName = string.Empty;
        private string path;
        private string currentValue;
        private ObservableCollection<PageValue> valueList { get; set; } = new ObservableCollection<PageValue>();
        protected override void OnInitialize()
        {
            base.OnInitialize();
            this.SystemName = "System";
            ConfigNodes = SystemConfigProvider.Instance.GetConfigTree(SystemName).SubNodes;

            InitTree();
            _rootNode = SystemConfigProvider.Instance.GetConfig(true);
        }
        protected override void OnActivate()
        {
            base.OnActivate();
            DefaultUnit = (string)QueryDataClient.Instance.Service.GetConfig("APC.PressureUnit");
        }
        private void InitTree()
        {
            var node = SystemConfigProvider.Instance.GetConfigTree(SystemName).SubNodes;
            ParameterTree.Add(new ParamBase() { ID = 1, ParentID = 0, Name = "StepTime", ConfigName = "StepTime" });

            ParameterTree.Add(new ParamBase() { ID = 2, ParentID = 0, Name = "TempSetting", ConfigName = "TempSetting" });
            
            ParameterTree.Add(new ParamBase() { ID = 3, ParentID = 0, Name = "WaferCycleTime", ConfigName = "WaferCycleTime" });

            ParameterTree = this.LoadTreeView(0);
        }
        private List<ParamBase> LoadTreeView(int id)
        {
            List<ParamBase> node = ParameterTree.FindAll(s => s.ParentID.Equals(id));
            foreach (var item in node)
            {
                item.Children = LoadTreeView(item.ID);
            }
            return node;
        }
        public void HideAllCanvas()
        {
            var view = GetView() as MainParameterEditView;
            view.StepTime.Visibility = Visibility.Hidden;
            view.TempSetting.Visibility = Visibility.Hidden;
            view.WaferCycleTime.Visibility = Visibility.Hidden;
        }
        public void TreeViewSelectedItemChanged(object obj)
        {
            valueList.Clear();
            LevelOneNode = LevelTwoNode = new ConfigNode();
            HideAllCanvas();
            var view = GetView() as MainParameterEditView;
            ParamBase para = obj as ParamBase;
            string strHeader = "PM1.RecipeEditParameter";
            Canvas canvas = null;
            if (para.ConfigName == "WaferCycleTime")
                strHeader = "PM1";
            LevelOneNode = FindNodeByName(_rootNode, $"{strHeader}.{para.ConfigName}");
            LevelTwoNode = LevelOneNode.SubNodes.FirstOrDefault();
            switch (para.ConfigName)
            {
                case "StepTime":
                    canvas = view.StepTime;
                    break;
                case "TempSetting":
                    canvas = view.TempSetting;
                    InitItemsCurrentValue(LevelOneNode);
                    if (LevelOneNode.SubNodes.Where(x => x.TempSttingBoolValue == true).Count() <= 0)
                    {
                        LevelOneNode.SubNodes[0].TempSttingBoolValue = true;
                    }
                    break;
                case "WaferCycleTime":
                    canvas = view.WaferCycleTime;
                    break;
            }
            if (canvas == null) return;
            canvas.Visibility = Visibility.Visible;

            this.GetHeaderConfig();
            if (LevelTwoNode == null)
            {
                InitItemsCurrentValue(LevelOneNode, false);
            }
            else
            {
                InitItemsCurrentValue(LevelTwoNode, true);
                ConfigNode subNode = LevelTwoNode.SubNodes.FirstOrDefault();
                if (subNode != null) InitItemsCurrentValue(subNode, 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}.{node.Name}";
            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++)
            {

                var isInstalled = QueryDataClient.Instance.Service.GetConfig($"PM1.MFC.{CurrenItems[i].Name}.IsMFCInstalled");
                if (isInstalled != null && !(bool)isInstalled)
                    CurrenItems[i].Visible = false;
                else
                    CurrenItems[i].Visible = true;
                string key = String.Format("{0}{1}{2}", _CurrentNodeName, ".", CurrenItems[i].Name);
                CurrenItems[i].CurrentValue = SystemConfigProvider.Instance.GetValueByName(key);
                CurrenItems[i].Path = key;
                if (CurrenItems[i].Type == DataType.Bool)
                {
                    bool value;
                    if (bool.TryParse(CurrenItems[i].CurrentValue, out value))
                    {
                        CurrenItems[i].BoolValue = value;

                        CurrenItems[i].CurrentValue = value ? "Yes" : "No";
                    }
                }
                else
                    CurrenItems[i].StringValue = CurrenItems[i].CurrentValue;
            }
        }
        public void MenuCommand(object obj, object menuLevel)
        {

            RadioButton radioButton = obj as RadioButton;
            ConfigNode currentNode = null;
            switch (menuLevel.ToString())
            {
                case "LevelOne":
                    currentNode = LevelTwoNode = LevelOneNode.SubNodes.Find((x) => x.Name == radioButton.ToolTip.ToString());
                    break;
                case "LevelTwo":
                    currentNode = LevelTwoNode.SubNodes.Find((x) => x.Name == radioButton.ToolTip.ToString());
                    break;

            }
            InitItemsCurrentValue(currentNode);
        }
        public void SetValue(object obj)
        {
            var CurrentRecipes = CurrentRecipe;
            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;
                //key ：System.IsSimulatorMode 
                //value: true or false 都是字符串

                //input check
                string value;
                if (item.Type == DataType.Bool)
                {
                    if (item.StringValue.Equals("Yes", StringComparison.CurrentCultureIgnoreCase))
                        item.BoolValue = true;
                    else if (item.StringValue.Equals("No", StringComparison.CurrentCultureIgnoreCase))
                        item.BoolValue = false;
                    else
                    {
                        DialogBox.ShowWarning("The Value Should be Yes Or No.");
                        return;
                    }
                    value = item.BoolValue.ToString().ToLower();
                }
                else
                {
                    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;
                    }
                    else if (item.Type == DataType.Double)
                    {
                        double fValue;
                        if (double.TryParse(item.StringValue, out fValue))
                        {
                            if (!double.IsNaN(item.Max) && !double.IsNaN(item.Min))
                            {
                                if (fValue > item.Max || fValue < item.Min)
                                {
                                    DialogBox.ShowWarning(string.Format("The value should be between {0}  and {1}.", item.Min.ToString(), item.Max.ToString()));
                                    return;
                                }

                                string[] box = fValue.ToString().Split('.');
                                if (box.Length > 1 && box[1].Length > 3)
                                {
                                    DialogBox.ShowWarning(string.Format("The value should be more than three decimal places"));
                                    return;
                                }
                            }
                        }
                        else
                        {
                            DialogBox.ShowWarning("Please input valid data.");
                            return;
                        }
                        value = item.StringValue;
                    }
                    else
                        value = item.StringValue;
                }

                string key = String.Format("{0}{1}{2}", _CurrentNodeName, ".", item.Name);
                
                path = item.Path;
                currentValue = value;
                valueList.Add(new PageValue() { Path = path, CurrentValue = currentValue });
            }
        }

        public void SaveParameter()
        {
            foreach (var item in valueList)
            {
                InvokeClient.Instance.Service.DoOperation($"{SystemName}.SetConfig", item.Path, item.CurrentValue);
            }
        }

        public void GetHeaderConfig()
        {
            HeadLst.Clear();
            for (int i = 0; i < 10; i++)
            {
                if (i % 2 != 0)
                {
                    var configHeater = (string)QueryDataClient.Instance.Service.GetConfig($"PM1.Heater.Heater{i}.DisplayName");
                    TempSetData item = new TempSetData(configHeater);
                    item.SetValue.Value = configHeater;
                    HeadLst.Add(item);
                }
            }
        }

        private ConfigNode FindNodeByName(ConfigNode parentNode, string strName)
        {
            string strCates = strName.Split('.')[0];
            ConfigNode node = parentNode.SubNodes.Find((x) => x.Name == strCates);
            if (node == null)
                return parentNode;
            else
                return FindNodeByName(node, strName.Replace(strCates + ".", ""));
        }
    }
    public class ParamBase
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public int ParentID { get; set; }
        public string ConfigName { get; set; }
        public List<ParamBase> Children { get; set; }
        public ParamBase()
        {
            Children = new List<ParamBase>();
        }
    }

    public class ParameterConvert : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            return value.ToString().Replace("Table", "").Replace("LineNo", "");
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}