CyberX8/CyberX8_MainPages/ViewModels/PMCounterViewModel.cs

using Aitex.Core.UI.MVVM;
using CyberX8_Core;
using MECF.Framework.Common.CommonData.Reservoir;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.ProcessCell;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.Utilities;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;

namespace CyberX8_MainPages.ViewModels
{
    public class PMCounterViewModel : BindableBase
    {
        #region 常量
        private const string RESERVOIRS_DATA = "ReservoirsData";
        private const string PERSISTENT_VALUE = "PersistentValue";
        #endregion
        #region 内部变量
        private string _module;
        private string _recipeContent;
        private string _state;
        private List<string> _rtDataKeys = new List<string>();
        DispatcherTimer _timer;
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
        private ObservableCollection<RecipeNode> _recipeNodes;
        private string _currentRecipeFileName;
        private string _recipeType;
        private ResRecipe _currentRecipe;
        

        /// <summary>
        /// Persistent
        /// </summary>
        private ReservoirsPersistentValue _reservoirsPersistent;
        /// <summary>
        /// Reservoir数据
        /// </summary>
        private CompactMembranReservoirData _reservoirData;
        /// <summary>
        /// CellModuleName集合
        /// </summary>
        private ObservableCollection<string> _cellModuleNameCollection = new ObservableCollection<string>();
        /// <summary>
        /// PM Counter元素集合
        /// </summary>
        private ObservableCollection<PMCounterNode> _componentNodes = new ObservableCollection<PMCounterNode>();
        /// <summary>
        /// Reservoir在PM counter页面的数据项
        /// </summary>
        private PMCounterNode _reservoirPMCounterNode = new PMCounterNode();
        /// <summary>
        /// 页面功能启用
        /// </summary>
        private bool _isEnabled;
        /// <summary>
        /// AutoMode页面功能启用
        /// </summary>
        private bool _isAutoEnabled;
        #endregion
        #region 属性
        public string CurrentRecipeFileName
        {
            get { return _currentRecipeFileName; }
            set { SetProperty(ref _currentRecipeFileName, value); }
        }
        public ObservableCollection<RecipeNode> RecipeNodes
        {
            get { return _recipeNodes; }
            set { SetProperty(ref _recipeNodes, value); }
        }
        public string Module { get { return _module; } set { SetProperty(ref _module, value); } }
        public string ReservoirRecipeContent
        {
            get { return _recipeContent; }
            set { SetProperty(ref _recipeContent, value); }
        }
        public string State
        {
            get { return _state; }
            set { SetProperty(ref _state, value); }
        }

        public ResRecipe CurrentRecipe
        {
            get { return _currentRecipe; }
            set { SetProperty(ref _currentRecipe, value); }
        }
        public string RecipeType
        {
            get { return _recipeType; }
            set { SetProperty(ref _recipeType, value); }
        }

        /// <summary>
        /// Threshold
        /// </summary>
        public ReservoirsPersistentValue ReservoirsPersistent
        {
            get { return _reservoirsPersistent; }
            set { SetProperty(ref _reservoirsPersistent, value); }
        }
        /// <summary>
        /// CellModuleName集合
        /// </summary>
        public ObservableCollection<string> CellModuleNameCollection
        {
            get { return _cellModuleNameCollection; }
            set { SetProperty(ref _cellModuleNameCollection, value); }
        }
        /// <summary>
        /// PM Counter元素集合
        /// </summary>
        public ObservableCollection<PMCounterNode> ComponentNodes
        {
            get { return _componentNodes; }
            set { SetProperty(ref _componentNodes, value); }
        }
        /// <summary>
        /// Reservoir在PM Counter页面的数据项
        /// </summary>
        public PMCounterNode ReservoirPMCounterNode
        {
            get { return _reservoirPMCounterNode; }
            set { SetProperty(ref _reservoirPMCounterNode, value); }
        }
        /// <summary>
        /// Reservoir 数据
        /// </summary>
        public CompactMembranReservoirData ReservoirData
        {
            get { return _reservoirData; }
            set { SetProperty(ref _reservoirData, value); }
        }
        /// <summary>
        /// 页面功能启用
        /// </summary>
        public bool IsEnabled
        {
            get { return _isEnabled; }
            set { SetProperty(ref _isEnabled, value); }
        }
        /// <summary>
        /// AutoMode页面功能启用
        /// </summary>
        public bool IsAutoEnabled
        {
            get { return _isAutoEnabled; }
            set { SetProperty(ref _isAutoEnabled, value); }
        }
        #endregion

        #region 命令

        public ICommand BackCommand { get; set; }
        public ICommand KeyDownCommand { get; set; }

        #endregion


        /// <summary>
        /// 构造器
        /// </summary>
        public PMCounterViewModel()
        {
            BackCommand = new DelegateCommand<object>(BackAction);
            KeyDownCommand = new DelegateCommand<object>(KeyDownAction);
        }

        public void LoadData(string systemName)
        {
            Module = systemName;
            ReservoirPMCounterNode.Name = systemName;
            ReservoirPMCounterNode.Children = new ObservableCollection<PMCounterCommonData>();
            ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = "ComponentName", CounterName = "Counter Name", Value = "Value", FaultLimit = "FaultLimit", WarningLimit = "WarningLimit" });
            _rtDataKeys.Clear();
            _rtDataKeys.Add($"{Module}.ReservoirUsage");
            _rtDataKeys.Add($"{Module}.IsCMMInstalled");
            Dictionary<string, object> reservoirUsageDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
            if (reservoirUsageDic != null)
            {
                ReservoirUsage reservoirUsage = CommonFunction.GetValue<ReservoirUsage>(reservoirUsageDic, $"{Module}.ReservoirUsage");
                bool isCMMInstalled = CommonFunction.GetValue<bool>(reservoirUsageDic, $"{Module}.IsCMMInstalled");
                if (reservoirUsage != null)
                {
                    double ReservoirTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.ReservoirTotalAmpHoursWarningLimit"));
                    double ReservoirTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.ReservoirTotalAmpHoursFaultLimit"));
                    double BathTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.BathTotalAmpHoursWarningLimit"));
                    double BathTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.BathTotalAmpHoursFaultLimit"));
                    double ANBathTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.ANBathTotalAmpHoursWarningLimit"));
                    double ANBathTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.ANBathTotalAmpHoursFaultLimit"));
                    int BathTotalDaysWarningLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.BathTotalDaysWarningLimit"));
                    int BathTotalDaysFaultLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.BathTotalDaysFaultLimit"));
                    double MembraneTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.MembraneTotalAmpHoursWarningLimit"));
                    double MembraneTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.MembraneTotalAmpHoursFaultLimit"));
                    int ReservoirTotalWafersWarningLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.ReservoirTotalWafersWarningLimit"));
                    int ReservoirTotalWafersFaultLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.ReservoirTotalWafersFaultLimit"));         
                    ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "Total Usage(AHr)", Value = $"{reservoirUsage.TotalUsage}", FaultLimit = $"{ReservoirTotalAmpHoursFaultLimit}", WarningLimit = $"{ReservoirTotalAmpHoursWarningLimit}" });
                    ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "Bath Usage(AHr)", Value = $"{reservoirUsage.BathUsage}", FaultLimit = $"{BathTotalAmpHoursFaultLimit}", WarningLimit = $"{BathTotalAmpHoursWarningLimit}" });
                    ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "Anolyte Bath Usage(AHr)", Value = $"{reservoirUsage.AnodeUsage}", FaultLimit = $"{ANBathTotalAmpHoursFaultLimit}", WarningLimit = $"{ANBathTotalAmpHoursWarningLimit}" });
                    ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "Bath Usage(Days)", Value = $"{reservoirUsage.BathUsageDays}", FaultLimit = $"{BathTotalDaysFaultLimit}", WarningLimit = $"{BathTotalDaysWarningLimit}" });
                    ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "Membrance Usage(AHr)", Value = $"{reservoirUsage.MembranceUsage}", FaultLimit = $"{MembraneTotalAmpHoursFaultLimit}", WarningLimit = $"{MembraneTotalAmpHoursWarningLimit}" });
                    ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "Total Wafers", Value = $"{reservoirUsage.TotalWafers}", FaultLimit = $"{ReservoirTotalWafersFaultLimit}", WarningLimit = $"{ReservoirTotalWafersWarningLimit}" });
                    if (isCMMInstalled)
                    {
                        double CMMAnodeTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.CMM.CMMAnodeTotalAmpHoursWarningLimit"));
                        double CMMAnodeTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.CMM.CMMAnodeTotalAmpHoursFaultLimit"));
                        double CMMCathodeTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.CMM.CMMCathodeTotalAmpHoursWarningLimit"));
                        double CMMCathodeTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Reservoir.CMM.CMMCathodeTotalAmpHoursFaultLimit"));
                        ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "CMM Anode Usage(AHr)", Value = $"{reservoirUsage.CMMAnodeUsage}", FaultLimit = $"{CMMAnodeTotalAmpHoursFaultLimit}", WarningLimit = $"{CMMAnodeTotalAmpHoursWarningLimit}" });
                        ReservoirPMCounterNode.Children.Add(new PMCounterCommonData { ComponentName = $"{Module}", CounterName = "CMM Cathode Usage(AHr)", Value = $"{reservoirUsage.CMMMembranceUsage}", FaultLimit = $"{CMMCathodeTotalAmpHoursFaultLimit}", WarningLimit = $"{CMMCathodeTotalAmpHoursWarningLimit}" });
                    }
                    
                }
            }
            _rtDataKeys.Clear();
            _rtDataKeys.Add($"{Module}.Metals");
            Dictionary<string, object> tmpMetals = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
            if (tmpMetals != null)
            {
                List<string> strMetals = CommonFunction.GetValue<List<string>>(tmpMetals, $"{Module}.Metals");
                int cellsCount = strMetals.Count;
                if (strMetals != null)
                {
                    CellModuleNameCollection.Clear();
                    ComponentNodes.Clear();
                    for (int i = 0; i < cellsCount; i++)
                    {
                        CellModuleNameCollection.Add(strMetals[i]);
                        ComponentNodes.Add(new PMCounterNode { Name = $"{strMetals[i]}", Children = new ObservableCollection<PMCounterCommonData>() });
                        ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = "ComponentName", CounterName = "Counter Name", Value = "Value", FaultLimit = "FaultLimit", WarningLimit = "WarningLimit" });
                        _rtDataKeys.Clear();
                        _rtDataKeys.Add($"{strMetals[i]}.MetalUsage");
                        Dictionary<string, object> tmpMetalUsage = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                        if(tmpMetalUsage != null) 
                        {
                            MetalUsage metalUsage = CommonFunction.GetValue<MetalUsage>(tmpMetalUsage, $"{strMetals[i]}.MetalUsage");
                            if (metalUsage != null)
                            {
                                double metalTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MetalTotalAmpHoursWarningLimit"));
                                double metalTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MetalTotalAmpHoursFaultLimit"));
                                double anodeATotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeATotalAmpHoursWarningLimit"));
                                double anodeATotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeATotalAmpHoursFaultLimit"));
                                double anodeBTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeBTotalAmpHoursWarningLimit"));
                                double anodeBTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeBTotalAmpHoursFaultLimit"));
                                double membraneATotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MembraneATotalAmpHoursWarningLimit"));
                                double membraneATotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MembraneATotalAmpHoursFaultLimit"));
                                double membraneBTotalAmpHoursWarningLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MembraneBTotalAmpHoursWarningLimit"));
                                double membraneBTotalAmpHoursFaultLimit = (double)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MembraneBTotalAmpHoursFaultLimit"));
                                int metalTotalWafersWarningLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MetalTotalWafersWarningLimit"));
                                int metalTotalWafersFaultLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.MetalTotalWafersFaultLimit"));
                                int anodeATotalWafersWarningLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeATotalWafersWarningLimit"));
                                int anodeATotalWafersFaultLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeATotalWafersFaultLimit"));
                                int anodeBTotalWafersWarningLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeBTotalWafersWarningLimit"));
                                int anodeBTotalWafersFaultLimit = (int)Convert.ToDouble(QueryDataClient.Instance.Service.GetConfig("Metal.AnodeBTotalWafersFaultLimit"));
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Total Usage(AHr)", Value = $"{metalUsage.TotalUsage}", FaultLimit = $"{metalTotalAmpHoursFaultLimit}", WarningLimit = $"{metalTotalAmpHoursWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Anode A Usage(AHr)", Value = $"{metalUsage.AnodeAUsage}", FaultLimit = $"{anodeATotalAmpHoursFaultLimit}", WarningLimit = $"{anodeATotalAmpHoursWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Anode B Usage(AHr)", Value = $"{metalUsage.AnodeBUsage}", FaultLimit = $"{anodeBTotalAmpHoursFaultLimit}", WarningLimit = $"{anodeBTotalAmpHoursWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Membrane A Usage(AHr)", Value = $"{metalUsage.MembranceAUsage}", FaultLimit = $"{membraneATotalAmpHoursFaultLimit}", WarningLimit = $"{membraneATotalAmpHoursWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Membrane B Usage(AHr)", Value = $"{metalUsage.MembranceBUsage}", FaultLimit = $"{membraneBTotalAmpHoursFaultLimit}", WarningLimit = $"{membraneBTotalAmpHoursWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Metal Total Wafers", Value = $"{metalUsage.TotalWafers}", FaultLimit = $"{metalTotalWafersFaultLimit}", WarningLimit = $"{metalTotalWafersWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Anode A Total Wafers", Value = $"{metalUsage.AnodeAWafers}", FaultLimit = $"{anodeATotalWafersFaultLimit}", WarningLimit = $"{anodeATotalWafersWarningLimit}" });
                                ComponentNodes[i].Children.Add(new PMCounterCommonData { ComponentName = $"{strMetals[i]}", CounterName = "Anode B Total Wafers", Value = $"{metalUsage.AnodeBWafers}", FaultLimit = $"{anodeBTotalWafersFaultLimit}", WarningLimit = $"{anodeBTotalWafersWarningLimit}" });
                            }
                        }
                    }
                } 
                ComponentNodes.Add(ReservoirPMCounterNode);
            }           

            _rtDataKeys.Clear();
            _rtDataKeys.Add($"{Module}.{PERSISTENT_VALUE}");
            _rtDataKeys.Add($"{Module}.ReservoirData");
            _rtDataKeys.Add($"{Module}.CurrentRecipe");
            _rtDataKeys.Add($"{Module}.FsmState");
            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(200);
                _timer.Tick += Timer_Tick;
            }
            _timer.Start();
        }

        private void Timer_Tick(object sender, EventArgs e)
        {
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    State = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.FsmState");
                    ReservoirData = CommonFunction.GetValue<CompactMembranReservoirData>(_rtDataValueDic, $"{Module}.ReservoirData");
                    CurrentRecipe = CommonFunction.GetValue<ResRecipe>(_rtDataValueDic, $"{Module}.CurrentRecipe");
                    ReservoirsPersistent = CommonFunction.GetValue<ReservoirsPersistentValue>(_rtDataValueDic, $"{Module}.{PERSISTENT_VALUE}");
                    if ("Manual".Equals(ReservoirsPersistent.OperatingMode))
                    {
                        IsEnabled = true;
                        IsAutoEnabled = true;
                    }
                    else if ("Auto".Equals(ReservoirsPersistent.OperatingMode))
                    {
                        IsAutoEnabled = true;
                        IsEnabled = false;
                    }
                    else
                    {
                        State = "Stopped";
                        IsEnabled = false;
                        IsAutoEnabled = false;
                    }
                }
            }
        }

        #region 命令方法
        /// <summary>
        /// 回到Reservoir页面
        /// </summary>
        /// <param name="param"></param>
        private void BackAction(object param)
        {
            GlobalEvents.OnSwitchFixedChildSubItem(Module, Module);
        }
        private void KeyDownAction(object param)
        {
            
        }
        #endregion
    }
}