CyberX8/Framework/Common/ToolLayout/ReservoirItemManager.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace MECF.Framework.Common.ToolLayout
{
    public class ReservoirItemManager : Singleton<ReservoirItemManager>
    {
        #region 常量
        /// <summary>
        /// 前缀
        /// </summary>
        private const string PREFIX = "Reservoir";
        #endregion

        #region 内部变量
        /// <summary>
        /// 字典
        /// </summary>
        private Dictionary<string,ReservoirItem> _reservoirItemDictionary=new Dictionary<string, ReservoirItem>();
        /// <summary>
        /// 化学液Metal集合字典
        /// </summary>
        private Dictionary<string, List<MetalItem>> _chemistryMetalItemDictionary = new Dictionary<string, List<MetalItem>>();
        /// <summary>
        /// Metal-Reservoir字典
        /// </summary>
        private Dictionary<string, string> _metalReservoirDictionary = new Dictionary<string, string>();
        /// <summary>
        /// TC-Reservoir字典
        /// </summary>
        private Dictionary<string, string> _tcReservoirDictionary=new Dictionary<string, string>();
        /// <summary>
        /// Reservoir-Metals字典(key-reservoir名称,value-Metals集合)
        /// </summary>
        private SerializableDictionary<string, List<string>> _reseroirMetalsDictionary = new SerializableDictionary<string, List<string>>();
        #endregion

        #region 属性
        /// <summary>
        /// 已经安装模块
        /// </summary>
        public List<string> InstalledModules { get; private set; } = new List<string>();
        /// <summary>
        /// Reservoir-Metals字典
        /// </summary>
        public SerializableDictionary<string,List<string>> ReservoirMetalsDictionary { get { return _reseroirMetalsDictionary; }}
        #endregion

        /// <summary>
        /// 初始化Reservoir 
        /// </summary>
        /// <param name="rinservoirElement"></param>
        public void InitializeReservoirItem(XmlElement reservoirElement)
        {
            ReservoirItem reservoirItem = new ReservoirItem();
            reservoirItem.Installed = bool.Parse(reservoirElement.SelectSingleNode("Installed").InnerText);
            reservoirItem.ReservoirID = int.Parse(reservoirElement.SelectSingleNode("ReservoirID").InnerText);
            reservoirItem.SubType = reservoirElement.SelectSingleNode("SubType").InnerText;
            reservoirItem.TCID = reservoirElement.SelectSingleNode("TCID").InnerText;
            reservoirItem.PHProbeChannelNumber = int.Parse(reservoirElement.SelectSingleNode("PHProbeChannelNumber").InnerText);
            reservoirItem.PlannedInitialChemistry = reservoirElement.SelectSingleNode("PlannedInitialChemistry").InnerText;
            string key = $"{PREFIX}{reservoirItem.ReservoirID}";
            _tcReservoirDictionary[reservoirItem.TCID] = key;
            reservoirItem.MetalCells = new List<MetalItem>();
            XmlNodeList itemsNode = reservoirElement.SelectNodes("MetalCells/Item");
            List<string> metals = new List<string>();
            foreach (var item in itemsNode)
            {
                XmlElement element = item as XmlElement;
                MetalItem metalItem = MetalItemManager.Instance.InitializeMetalItem(element);
                MetalItemManager.Instance.AddMetalItem(metalItem);
                reservoirItem.MetalCells.Add(metalItem);
                if(reservoirItem.Installed&&metalItem.Installed)
                {
                    List<MetalItem> lst = new List<MetalItem>();
                    if(_chemistryMetalItemDictionary.ContainsKey(reservoirItem.PlannedInitialChemistry))
                    {
                        lst = _chemistryMetalItemDictionary[reservoirItem.PlannedInitialChemistry];
                    }
                    else
                    {
                        _chemistryMetalItemDictionary[reservoirItem.PlannedInitialChemistry] = lst;
                    }
                    if(lst.FindIndex(O=>O.MetalID==metalItem.MetalID)==-1)
                    {
                        lst.Add(metalItem);
                    }
                    _metalReservoirDictionary[metalItem.ModuleName] = key;
                    if (!metals.Contains(metalItem.ModuleName))
                    {
                        metals.Add(metalItem.ModuleName);
                    }
                }
            }

            if (reservoirItem.Installed)
            {
                _reseroirMetalsDictionary[key] = metals;
            }

            reservoirItem.CellPosition = int.Parse(reservoirElement.SelectSingleNode("CellPosition").InnerText);
            reservoirItem.PositionInMilliMeters = int.Parse(reservoirElement.SelectSingleNode("PositionInMilliMeters").InnerText);
            reservoirItem.LengthInMilliMeters = int.Parse(reservoirElement.SelectSingleNode("LengthInMilliMeters").InnerText);
            reservoirItem.ChemicalReplenishmentEnable = bool.Parse(reservoirElement.SelectSingleNode("ChemicalReplenishmentEnable").InnerText);
            reservoirItem.DIReplenType = reservoirElement.SelectSingleNode("DIReplenType").InnerText;
            reservoirItem.ANDIReplenType = reservoirElement.SelectSingleNode("ANDIReplenType").InnerText;
            reservoirItem.PHProbeType = reservoirElement.SelectSingleNode("PHProbeType").InnerText;
            reservoirItem.CrossDoseType = reservoirElement.SelectSingleNode("CrossDoseType").InnerText;
            reservoirItem.ChemReplenType = reservoirElement.SelectSingleNode("ChemReplenType").InnerText;
            reservoirItem.ChemReplenPumps = int.Parse(reservoirElement.SelectSingleNode("ChemReplenPumps").InnerText);
            reservoirItem.AutoDrainsInstalled = bool.Parse(reservoirElement.SelectSingleNode("AutoDrainsInstalled").InnerText);
            reservoirItem.SlipstreamType = reservoirElement.SelectSingleNode("SlipstreamType").InnerText;
            reservoirItem.CMMType = reservoirElement.SelectSingleNode("CMMType").InnerText;
            reservoirItem.CMMSupplyID = reservoirElement.SelectSingleNode("CMMSupplyID").InnerText;
            reservoirItem.EvaporatorType = reservoirElement.SelectSingleNode("EvaporatorType").InnerText;
            DATA.Subscribe($"{key}.CMMPowerSupplier", () => { return reservoirItem.CMMSupplyID; }, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            if (reservoirItem.Installed && !InstalledModules.Contains(key))
            {
                InstalledModules.Add(key);                
            }
            _reservoirItemDictionary[key] = reservoirItem;
        }
        /// <summary>
        /// 获取Reservoir对象
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public ReservoirItem GetReservoirItem(string moduleName)
        {
            return _reservoirItemDictionary.ContainsKey(moduleName) ? _reservoirItemDictionary[moduleName] : null;
        }
        /// <summary>
        /// 根据化学液获取所有Metal集合
        /// </summary>
        /// <param name="chemistry"></param>
        /// <returns></returns>
        public List<MetalItem> GetAllMetalItemsByChemistry(string chemistry)
        {
            return _chemistryMetalItemDictionary.ContainsKey(chemistry)?_chemistryMetalItemDictionary[chemistry]: null;
        }
        /// <summary>
        /// 根据Metal获取Reservoir
        /// </summary>
        /// <param name="metalName"></param>
        /// <returns></returns>
        public string GetReservoirByMetal(string metalName)
        {
            return _metalReservoirDictionary.ContainsKey(metalName) ? _metalReservoirDictionary[metalName] : "";
        }
        /// <summary>
        /// 根据TC获取Reservoir
        /// </summary>
        /// <param name="tcName"></param>
        /// <returns></returns>
        public string GetReservoirByTC(string tcName)
        {
            return _tcReservoirDictionary.ContainsKey(tcName) ? _tcReservoirDictionary[tcName] : "";
        }
        /// <summary>
        /// 获取Reservoir下面Metals
        /// </summary>
        /// <param name="reservoirName"></param>
        /// <returns></returns>
        public List<string> GetMetalsByReservoir(string reservoirName)
        {
            return _reseroirMetalsDictionary.ContainsKey(reservoirName)?_reseroirMetalsDictionary[reservoirName] : null;
        }
    }
}