PunkHPX8/PunkHPX8_MainPages/ViewModels/DepRecipeViewModel.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Log;
using Aitex.Core.UI.Dialog;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Utilities;
using Caliburn.Micro.Core;
using PunkHPX8_Core;
using PunkHPX8_MainPages.PMs;
using PunkHPX8_Themes.UserControls;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Utilities;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace PunkHPX8_MainPages.ViewModels
{
    public class DepRecipeViewModel : BindableBase
    {
        #region 常量
        private const string ENGINEERING = "Engineering";

        private const string DEP = "dep";
        #endregion

        #region 内部变量
        /// <summary>
        /// Recipe节点字典
        /// </summary>
        private Dictionary<string, RecipeNode> _recipeNodeDic = new Dictionary<string, RecipeNode>();
        /// <summary>
        /// 属性检验结果字典
        /// </summary>
        private Dictionary<string, bool> _propertyValidResultDic = new Dictionary<string, bool>();
        /// <summary>
        /// Recipe节点集合
        /// </summary>
        private ObservableCollection<RecipeNode> _recipeNodes;
        /// <summary>
        /// uiRecipeManager
        /// </summary>
        private UiRecipeManager _uiRecipeManager = new UiRecipeManager();
        /// <summary>
        /// recipe
        /// </summary>
        private DepRecipe _recipe;
        /// <summary>
        /// 编辑可用性
        /// </summary>
        private bool _editEnable;
        /// <summary>
        /// 创建可用性
        /// </summary>
        private bool _createEnable;
        /// <summary>
        /// 当前节点
        /// </summary>
        private RecipeNode _currentNode;
        /// <summary>
        /// 是否可用
        /// </summary>
        private bool _enable = false;
        /// <summary>
        /// 是否为编辑(true-Edit,false-add)
        /// </summary>
        private bool _isEdit = false;
        /// <summary>
        /// 化学液集合
        /// </summary>
        private List<string> _chemistryList = new List<string>();
        /// <summary>
        /// 显示MultiZone列
        /// </summary>
        private bool _multiZoneShow = false;
        /// <summary>
        /// 显示SingleZone列
        /// </summary>
        private bool _singleZoneShow = false;
        /// <summary>
        /// 选择AnodeType
        /// </summary>
        private string _selectAnodeType;
        /// <summary>
        /// Ramp DataGrid选择索引
        /// </summary>
        private int _selectedRampIndex = -1;
        /// <summary>
        /// Pulse DataGrid选择索引
        /// </summary>
        private int _selectedPulseIndex = -1;
        #endregion

        #region 属性
        public ObservableCollection<RecipeNode> RecipeNodes
        {
            get { return _recipeNodes; }
            set { SetProperty(ref _recipeNodes, value); }
        }
        /// <summary>
        /// Recipe
        /// </summary>
        public DepRecipe Recipe
        {
            get { return _recipe; }
            set { SetProperty(ref _recipe, value); }
        }
        /// <summary>
        /// 创建可用性
        /// </summary>
        public bool CreateEnable
        {
            get { return _createEnable; }
            set { SetProperty(ref _createEnable, value);}
        }
        /// <summary>
        /// 编辑可用性
        /// </summary>
        public bool EditEnable
        {
            get { return _editEnable; }
            set { SetProperty(ref _editEnable, value);}
        }
        /// <summary>
        /// 当前节点
        /// </summary>
        public RecipeNode CurrentNode
        {
            get { return _currentNode; }
            set { SetProperty(ref _currentNode, value);}
        }
        /// <summary>
        /// 可用性
        /// </summary>
        public bool Enable
        {
            get { return _enable; }
            set { SetProperty(ref _enable, value); }
        }
        /// <summary>
        /// 属性数据检验结果
        /// </summary>
        public Dictionary<string, bool> PropertyValidResultDic
        {
            get { return _propertyValidResultDic; }
            set { SetProperty(ref _propertyValidResultDic, value); }
        }
        /// <summary>
        /// 化学液集合
        /// </summary>
        public List<string> ChemistryList
        {
            get { return _chemistryList; }
            set { SetProperty(ref _chemistryList, value); }
        }
        /// <summary>
        /// MultiZone 显示
        /// </summary>
        public bool MultiZoneShow
        {
            get { return _multiZoneShow; }
            set 
            { 
                SetProperty(ref _multiZoneShow, value);
                SingleZoneShow = !value;
            }
        }
        /// <summary>
        /// SingleZone显示列
        /// </summary>
        public bool SingleZoneShow
        {
            get { return _singleZoneShow; }
            set { SetProperty(ref _singleZoneShow, value);}
        }

        /// <summary>
        /// DataGrid 索引
        /// </summary>
        public int SelectedRampIndex
        {
            get { return _selectedRampIndex; }
            set { SetProperty(ref _selectedRampIndex, value);}
        }
        /// <summary>
        /// Pulse Datagrid选择索引
        /// </summary>
        public int SelectedPulseIndex
        {
            get { return _selectedPulseIndex; }
            set { SetProperty(ref _selectedPulseIndex, value); }
        }

        #endregion

        #region 指令
        [IgnorePropertyChange]
        public ICommand OperationCommand
        {
            get;
            private set;
        }

        [IgnorePropertyChange]
        public ICommand CreateCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand EditCommand {  get; private set; }
        [IgnorePropertyChange]
        public ICommand SaveRecipeCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand SaveAsRecipeCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand AddBelowCommand { get;private set; }
        [IgnorePropertyChange]
        public ICommand AddAboveCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand MoveUpCommand { get; private set; }
        [IgnorePropertyChange]
        public ICommand MoveDownCommand { get; private set; }

        [IgnorePropertyChange]
        public ICommand DeleteCommand { get;private set; }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        public DepRecipeViewModel()
        {
            OperationCommand = new DelegateCommand<object>(SelectionChangedAction);
            CreateCommand = new DelegateCommand<object>(CreateAction);
            EditCommand = new DelegateCommand<object>(EditAction);
            SaveRecipeCommand = new DelegateCommand<object>(SaveAction);
            SaveAsRecipeCommand = new DelegateCommand<object>(SaveAsAction);
            AddBelowCommand = new DelegateCommand<object>(AddBelowAction);
            AddAboveCommand = new DelegateCommand<object>(AddAboveAction);
            MoveUpCommand=new DelegateCommand<object>(MoveUpAction);
            MoveDownCommand=new DelegateCommand<object>(MoveDownAction);
            DeleteCommand=new DelegateCommand<object>(DeleteAction);

            string chemistryContent = QueryDataClient.Instance.Service.GetConfig($"System.ChemistryList").ToString();
            if (!string.IsNullOrEmpty(chemistryContent))
            {
                ChemistryList = chemistryContent.Split(',').ToList();
            }

            InitializeProprtyValidResultDictionary();

        }
        /// <summary>
        /// 初始化属性数据检验结果字典
        /// </summary>
        private void InitializeProprtyValidResultDictionary()
        {
            PropertyValidResultDic["EntrySpinSpeed"] = false;
            PropertyValidResultDic["EntryZoffset"] = false;
            PropertyValidResultDic["PlatingDelay"] = false;
            PropertyValidResultDic["EntryCurrent"] = false;
            PropertyValidResultDic["EntryVoltage"] = false;
            PropertyValidResultDic["DepCurrentWarning"] = false;
            PropertyValidResultDic["DepCurrentFault"] = false;
            PropertyValidResultDic["DepMaxVoltageWarning"] = false;
            PropertyValidResultDic["DepMaxVoltageFault"] = false;
            PropertyValidResultDic["DepZoffset"] = false;
            PropertyValidResultDic["Section1Speed"] = false;
            PropertyValidResultDic["Section2Speed"] = false;
            PropertyValidResultDic["NormalSpeed"] = false;
            PropertyValidResultDic["ReclaimSpeed"] = false;
            PropertyValidResultDic["ReclaimTime"] = false;
            PropertyValidResultDic["ReclaimZoffset"] = false;
            PropertyValidResultDic["RinseSpeed"] = false;
            PropertyValidResultDic["RinseTime"] = false;
            PropertyValidResultDic["RinseZoffset"] = false;
            PropertyValidResultDic["DrySpeed"] = false;
            PropertyValidResultDic["DryTime"] = false;
            PropertyValidResultDic["DryZoffset"] = false;
            PropertyValidResultDic["IntervalRinseSpeed"] = false;
            PropertyValidResultDic["IntervalRinseTime"] = false;
            PropertyValidResultDic["IntervalRinseZoffset"] = false;
            
        }
        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadRecipeData()
        {
            RecipeNodes = _uiRecipeManager.GetRecipesByType(DEP);
            _recipeNodeDic.Clear();
            InitializeDictionary(RecipeNodes);
        }
        /// <summary>
        /// 初始化字典
        /// </summary>
        /// <param name="nodes"></param>
        private void InitializeDictionary(ObservableCollection<RecipeNode> nodes)
        {
            if (nodes != null)
            {
                foreach (var node in nodes)
                {
                    if (node.NodeType == RecipeNodeType.File)
                    {
                        _recipeNodeDic[node.Name] = node;
                    }
                    InitializeDictionary(node.Children);
                }
            }
        }

        /// <summary>
        /// 操作
        /// </summary>
        /// <param name="param"></param>
        private void SelectionChangedAction(object param)
        {
            if(_recipeNodeDic.ContainsKey(param.ToString()))
            {
                CurrentNode = _recipeNodeDic[param.ToString()];
                if(CurrentNode.NodeType==RecipeNodeType.File)
                {
                    if (CurrentNode.RecipeLocation == ENGINEERING)
                    {
                        EditEnable = true;
                        CreateEnable = true;
                    }
                    else
                    {
                        EditEnable= false;
                        CreateEnable = false;
                    }
                }
                Recipe = _uiRecipeManager.LoadRecipe<DepRecipe>(CurrentNode.RecipeFullFileName);
                if(Recipe==null)
                {
                    MessageBox.Show("Invalid Recipe", "Load Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    EditEnable = false;
                    CreateEnable = false;
                }
                Enable = false;
            }
            else
            {
                if(param.ToString()==ENGINEERING)
                {
                    CreateEnable= true;
                }
                else
                {
                    CreateEnable = false;
                }
                CurrentNode = null;
                Recipe = null;
                EditEnable = false;
                Enable = false;
            }
        }

        #region Action
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="param"></param>
        private void CreateAction(object param)
        {
            RecipeNameDialog recipeNameDialog = new RecipeNameDialog();
            if (recipeNameDialog.ShowDialog().Value)
            {
                Recipe = new DepRecipe();
                Recipe.CreateDate = DateTime.Now;
                Recipe.Ppid = recipeNameDialog.RecipeName;
                Recipe.Description=recipeNameDialog.RecipeDescription;
                Recipe.DepSteps = new ObservableCollection<CurrentRampProfile>();
                Enable = true;
                _isEdit = false;
            }
        }
        /// <summary>
        /// 编辑
        /// </summary>
        /// <param name="param"></param>
        private void EditAction(object param)
        {
            Enable = true;
            _isEdit= false;
        }
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="param"></param>
        private void SaveAction(object param)
        {
            if (CheckValid(_isEdit))
            {
                Recipe.SaveDate = DateTime.Now;

                int platingsteps = 0;
                int totaltime = 0;
                double totalcurrent = 0;
                foreach(var obj in Recipe.DepSteps)
                {
                    totaltime += obj.DurartionSeconds;
                    totalcurrent += (obj.CurrentValue * obj.DurartionSeconds);
                    platingsteps++;
                }
                //计算Deposition PlatingSteps
                Recipe.DepStepCount = platingsteps;
                //计算Deposition Totaltimes
                string date = string.Empty;
                var seconds = (int)(totaltime % 60);
                var minutes = (int)(totaltime / 60) % 60;
                var hours = (int)(totaltime / 3600) % 60;
                date = string.Format("{0:00}:{1:00}:{2:00}", hours + "h", minutes + "m", seconds + "s");
                Recipe.DepStepTotalTime = date;
                //计算Deposition TotalCurrent
                Recipe.DepStepTotalCurrent = totalcurrent / 3600;
                //计算TotalTime
                Recipe.TotalTime = totaltime + Recipe.PlatingDelay + 
                    Recipe.ReclaimTime + Recipe.RinseTime + Recipe.DryTime + Recipe.IntervalRinseTime;  
                try
                {
                    _uiRecipeManager.SaveRecipe<DepRecipe>(ENGINEERING, Recipe.Ppid,"dep", Recipe);
                    LoadRecipeData();
                    MessageBox.Show("Save Recipe Success", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Information);
                    Enable = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        /// <summary>
        /// 另存为
        /// </summary>
        /// <param name="param"></param>
        private void SaveAsAction(object param)
        {
            if (Recipe == null)
            {
                MessageBox.Show("Select a Recipe first", "SaveAs Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            DepRecipe recipe = new DepRecipe();
            if (CheckValid(_isEdit))
            {
                RecipeNameDialog recipeNameDialog = new RecipeNameDialog();
                if (recipeNameDialog.ShowDialog().Value)
                {
                    if (!CheckNameExist(recipeNameDialog.RecipeName))
                    {
                        recipe = new DepRecipe();
                        recipe = (DepRecipe)PropertyUtil.Clone(Recipe);

                        recipe.CreateDate = DateTime.Now;
                        recipe.Ppid = recipeNameDialog.RecipeName;
                        recipe.Description = recipeNameDialog.RecipeDescription;
                    }
                    else if (recipeNameDialog.RecipeName != null)
                    {
                        MessageBox.Show("Name can not be Null", "Create Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }
                    else
                    {
                        return;
                    }
                }
                try
                {
                    _uiRecipeManager.SaveRecipe<DepRecipe>(ENGINEERING, recipe.Ppid, "dep", recipe);
                    LoadRecipeData();
                    MessageBox.Show("Save As Recipe Success", "SaveAs Recipe", MessageBoxButton.OK, MessageBoxImage.Information);
                    Enable = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "Save As Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
        }
        /// <summary>
        /// 检验名称是否已经存在
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private bool CheckNameExist(string name)
        {
            foreach (string item in _recipeNodeDic.Keys)
            {
                if (item == name)
                {
                    MessageBox.Show($"{name} is exsit", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 检验合法性
        /// </summary>
        /// <param name="editType"></param>
        /// <returns></returns>
        private bool CheckValid(bool editType)
        {
            foreach(string key in _propertyValidResultDic.Keys)
            {
                bool valid = _propertyValidResultDic[key];
                if(!valid)
                {
                    MessageBox.Show($"{key} data invalid", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                    return false;
                }
            }
            if(Recipe.EntryCurrent > 0 && Recipe.EntryVoltage > 0)
            {
                MessageBox.Show($"Entry Current and Entry Voltage can not both larger than 0", "Save Recipe", MessageBoxButton.OK, MessageBoxImage.Error);
                return false;
            }
            return true;
        }
        #region Ramp按钮
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void AddBelowAction(object param)
        {
            if (Recipe != null)
            {
                CurrentRampProfile currentRampProfile = new CurrentRampProfile();
                Recipe.DepSteps.Insert(SelectedRampIndex + 1, currentRampProfile);
                SelectedRampIndex++;
            }

        }
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="param"></param>
        private void AddAboveAction(object param)
        {
            if (Recipe != null)
            {
                CurrentRampProfile currentRampProfile = new CurrentRampProfile();
                if (SelectedRampIndex == -1)
                {
                    Recipe.DepSteps.Add(currentRampProfile);
                    SelectedRampIndex = 0;
                }
                else
                {
                    Recipe.DepSteps.Insert(SelectedRampIndex, currentRampProfile);
                    SelectedRampIndex--;
                }
            }
        }
        /// <summary>
        /// 上移
        /// </summary>
        /// <param name="param"></param>
        private void MoveUpAction(object param)
        {
            if (Recipe != null)
            {
                if(SelectedRampIndex>0)
                {
                    int currentIndex = SelectedRampIndex;
                    CurrentRampProfile currentRampProfile = Recipe.DepSteps[SelectedRampIndex];
                    Recipe.DepSteps.RemoveAt(SelectedRampIndex);
                    Recipe.DepSteps.Insert(currentIndex - 1,currentRampProfile);
                    SelectedRampIndex = currentIndex - 1;
                }
            }
        }
        /// <summary>
        /// 下移
        /// </summary>
        /// <param name="param"></param>
        private void MoveDownAction(object param)
        {
            if (Recipe != null)
            {
                if (SelectedRampIndex>=0&&SelectedRampIndex <Recipe.DepSteps.Count-1 &&Recipe.DepSteps.Count>1)
                {
                    int currentIndex = SelectedRampIndex;
                    CurrentRampProfile currentRampProfile = Recipe.DepSteps[SelectedRampIndex];
                    Recipe.DepSteps.RemoveAt(SelectedRampIndex);
                    Recipe.DepSteps.Insert(currentIndex + 1, currentRampProfile);
                    SelectedRampIndex = currentIndex + 1;
                }
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="param"></param>
        private void DeleteAction(object param)
        {
            if (SelectedRampIndex != -1)
            {
                if (Recipe != null && Recipe.DepSteps.Count > SelectedRampIndex)
                {
                    Recipe.DepSteps.RemoveAt(SelectedRampIndex);
                }
            }
        }
        #endregion

        #endregion
    }
}