CyberX8/Framework/Common/ToolLayout/CellItemManager.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Spreadsheet;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.WaferHolder;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.ToolLayout
{
    public class CellItemManager : Singleton<CellItemManager>
    {
        #region 常量 
        private const string PWT = "PWT";
        #endregion

        #region 内部变量
        /// <summary>
        /// cell数组
        /// </summary>
        private LayoutCellItem[] _layoutCellItems = new LayoutCellItem[50];
        /// <summary>
        /// cell模块Id字典(key-模块名称,value-cellId)
        /// </summary>
        private Dictionary<string,int> _layoutCellModuleIdDic= new Dictionary<string,int>();
        /// <summary>
        /// 安装好的cell项集合
        /// </summary>
        private List<LayoutCellItem> _installedLayoutCellItems = new List<LayoutCellItem>();
        /// <summary>
        /// CellId模块名称字典
        /// </summary>
        private Dictionary<string, string> _cellIdModuleNameDic = new Dictionary<string, string>();
        /// <summary>
        /// Cell Wafer字典
        /// </summary>
        private ConcurrentDictionary<string, bool> _cellWaferHolderDictionary = new ConcurrentDictionary<string, bool>();
        /// <summary>
        /// Metal-Rinse字典(key-Metal名称,value-Rinse集合)
        /// </summary>
        private Dictionary<string, List<LayoutCellItem>> _metalRinseDictionary = new Dictionary<string, List<LayoutCellItem>>();
        /// <summary>
        /// 共享Rinse集合
        /// </summary>
        private List<string> _sharedRinseList = new List<string>();
        /// <summary>
        /// Rinse-Metal集合字典(key-rinse，value--共享使用的Metal)
        /// </summary>
        private Dictionary<string, List<string>> _shardRinseMetals = new Dictionary<string, List<string>>();
        /// <summary>
        /// 共享Rinse Reservoir集合字典(key-rinse，value--共享使用的Reservoir)
        /// </summary>
        private Dictionary<string, List<string>> _shardRinseReservoirs = new Dictionary<string, List<string>>();
        #endregion
        /// <summary>
        /// 初始化LayoutCellItem
        /// </summary>
        /// <param name="item"></param>
        public void InitialLayoutCellItem(LayoutCellItem item)
        {
            if(item.CellID==0||!item.Installed)
            {
                return;
            }
            if(item.CellID<_layoutCellItems.Length)
            {
                _layoutCellItems[item.CellID] = item;
                if (!string.IsNullOrEmpty(item.ModuleName))
                {
                    _layoutCellModuleIdDic[item.ModuleName] = item.CellID;
                }
                _cellIdModuleNameDic[$"Cell{item.CellID}"] = item.ModuleName;
            }
        }
        /// <summary>
        /// 获取metal旁边的rinse集合
        /// </summary>
        /// <param name="metalName"></param>
        /// <returns></returns>
        private List<LayoutCellItem> GetMetalNearbyRinseItems(string metalName)
        {
            List<LayoutCellItem> layoutCellItems = new List<LayoutCellItem>();
            if (_layoutCellModuleIdDic.ContainsKey(metalName))
            {
                int cellId = _layoutCellModuleIdDic[metalName];
                bool checkBackRinse = false;
                for (int i = cellId - 1; i >= 0; i--)
                {
                    LayoutCellItem item = _layoutCellItems[i];
                    if (item == null)
                    {
                        continue;
                    }
                    if (item.ModuleType == ModuleType.Rinse.ToString())
                    {
                        RinseItem rinseItem = RinseItemManager.Instance.GetRinseItem(item.ModuleName);
                        if (rinseItem == null)
                        {
                            continue;
                        }
                        if (rinseItem.SubType == PWT)
                        {
                            continue;
                        }
                        if (item.Installed)
                        {
                            layoutCellItems.Add(item);
                            checkBackRinse = true;
                            break;
                        }
                    }
                    else if (item.ModuleType == ModuleType.Metal.ToString())
                    {
                        if (!checkBackRinse)
                        {
                            continue;
                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                bool checkForwardRinse = false;
                for (int i = cellId; i < _layoutCellItems.Length; i++)
                {
                    LayoutCellItem item = _layoutCellItems[i];
                    if (item == null)
                    {
                        continue;
                    }
                    if (item.ModuleType == ModuleType.Rinse.ToString())
                    {
                        RinseItem rinseItem = RinseItemManager.Instance.GetRinseItem(item.ModuleName);
                        if (rinseItem == null)
                        {
                            continue;
                        }
                        if (rinseItem.SubType == PWT)
                        {
                            continue;
                        }
                        if (item.Installed)
                        {
                            layoutCellItems.Add(item);
                            checkForwardRinse = true;
                            break;
                        }
                    }
                    else if (item.ModuleType == ModuleType.Metal.ToString())
                    {
                        if (!checkForwardRinse)
                        {
                            continue;
                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }

            }
            return layoutCellItems;
        }
        /// <summary>
        /// 获取所有Layout Cell项
        /// </summary>
        /// <returns></returns>
        public void InitializeLayoutCellItems()
        {
            foreach (LayoutCellItem item in _layoutCellItems)
            {
                if (item != null&&item.Installed)
                {
                    if (WaferHolderManager.Instance.HasWaferHolder(item.ModuleName))
                    {
                        _cellWaferHolderDictionary[item.ModuleName] = true;
                    }
                    else
                    {
                        _cellWaferHolderDictionary[item.ModuleName] = false;
                    }
                    _installedLayoutCellItems.Add(item);
                }
            }
            AnalyseMetalRinse();
            DATA.Subscribe("System.LayoutCellItems", () => _installedLayoutCellItems.Select(obj => obj.ModuleName).ToList(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            _cellWaferHolderDictionary[ModuleName.Transporter2.ToString()] = WaferHolderManager.Instance.HasWaferHolder(ModuleName.Transporter2.ToString());
            _cellWaferHolderDictionary[ModuleName.Transporter1.ToString()] = WaferHolderManager.Instance.HasWaferHolder(ModuleName.Transporter1.ToString());
            _cellWaferHolderDictionary["Loader"] = WaferHolderManager.Instance.HasWaferHolder("Loader");
            DATA.Subscribe("System.CellWaferHolderDictionary", () => _cellWaferHolderDictionary,SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 解析Metal Rinse的关系
        /// </summary>
        private void AnalyseMetalRinse()
        {
            List<string> reservoir = ReservoirItemManager.Instance.InstalledModules;
            List<string> rinseList = new List<string>();
            foreach (var item in reservoir)
            {
                List<string> metals=ReservoirItemManager.Instance.GetMetalsByReservoir(item);
                List<string> reservoirRinse = new List<string>();
                foreach(string metalItem in metals)
                {
                    List<LayoutCellItem> cellItems=GetMetalNearbyRinseItems(metalItem);
                    _metalRinseDictionary[metalItem] = cellItems;
                    foreach(LayoutCellItem cellItem in cellItems)
                    {
                        if(!reservoirRinse.Contains(cellItem.ModuleName))
                        {
                            reservoirRinse.Add(cellItem.ModuleName);
                        }
                    }
                }
                //解析所有共享Rinse集合
                foreach (string rinseItem in reservoirRinse)
                {
                    if(!rinseList.Contains(rinseItem))
                    {
                        rinseList.Add(rinseItem);
                    }
                    else
                    {
                        _sharedRinseList.Add(rinseItem);
                    }
                }
            }
            //解析共享Rinse所有Metal集合
            foreach (var item in _sharedRinseList)
            {
                List<string> lst = new List<string>();
                _shardRinseMetals[item]=lst;
                List<string> lstReservoirs = new List<string>();
                _shardRinseReservoirs[item]=lstReservoirs;
                foreach (string metalItem in _metalRinseDictionary.Keys)
                {
                    List<LayoutCellItem> rinseItems = _metalRinseDictionary[metalItem];
                    if(rinseItems.Find(O=>O.ModuleName== item) != null)
                    {
                        lst.Add(metalItem);
                        string reservoirName = ReservoirItemManager.Instance.GetReservoirByMetal(metalItem);
                        if (!lstReservoirs.Contains(reservoirName))
                        {
                            lstReservoirs.Add(reservoirName);
                        }
                    }
                }
            }            
        }

        /// <summary>
        /// 根据CellId获取Cell名称
        /// </summary>
        /// <param name="cellId"></param>
        /// <returns></returns>
        public string GetModuleNameByCellId(string cellId)
        {
            return _cellIdModuleNameDic.ContainsKey(cellId) ? _cellIdModuleNameDic[cellId] : "";
        }
        /// <summary>
        /// 根据模块名称获取cellId
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public int GetCellIdByModuleName(string moduleName)
        {
            return _layoutCellModuleIdDic.ContainsKey(moduleName) ? _layoutCellModuleIdDic[moduleName] : 0;
        }

        /// <summary>
        /// 更新Cell 存在WaferHolder状态
        /// </summary>
        /// <param name="cellName"></param>
        /// <param name="hasWaferHolder"></param>
        public void UpdateCellWaferHolder(string cellName, bool hasWaferHolder)
        {
            if (_cellWaferHolderDictionary.ContainsKey(cellName))
            {
                _cellWaferHolderDictionary[cellName] = hasWaferHolder;
            }
        }
        /// <summary>
        /// 根据Metal获取关联Rinse集合
        /// </summary>
        /// <param name="metalName"></param>
        /// <returns></returns>
        public List<LayoutCellItem> GetRinseItemsByMetal(string metalName)
        {
            return _metalRinseDictionary.ContainsKey(metalName) ? _metalRinseDictionary[metalName] : null;
        }
        /// <summary>
        /// 检验Rinse是否共享
        /// </summary>
        /// <param name="rinseName"></param>
        /// <returns></returns>
        public bool CheckRinseIsShared(string rinseName)
        {
            return _sharedRinseList.Contains(rinseName);
        }
        /// <summary>
        /// 根据共享Rinse获取所有Metals
        /// </summary>
        /// <param name="sharedRinseName"></param>
        /// <returns></returns>
        public List<string> GetMetalsBySharedRinse(string sharedRinseName)
        {
            return _shardRinseMetals.ContainsKey(sharedRinseName)?_shardRinseMetals[sharedRinseName] : null;
        }
        /// <summary>
        /// 根据共享Rinse获取所有Reservoirs
        /// </summary>
        /// <param name="sharedRinseName"></param>
        /// <returns></returns>
        public List<string> GetReservoirsBySharedRinse(string sharedRinseName)
        {
            return _shardRinseReservoirs.ContainsKey(sharedRinseName) ? _shardRinseReservoirs[sharedRinseName] : null;
        }
        /// <summary>
        /// 根据Reservoir获取Rinse集合
        /// </summary>
        /// <param name="reservoirName"></param>
        /// <returns></returns>
        public List<string> GetRinsesByReservoir(string reservoirName)
        {
            List<string> metals = ReservoirItemManager.Instance.GetMetalsByReservoir(reservoirName);
            List<string> rinses= new List<string>();
            foreach (string metal in metals)
            {
                List<LayoutCellItem> metalRinses = _metalRinseDictionary[metal];
                foreach (LayoutCellItem rinseItem in metalRinses)
                {
                    if(!rinses.Contains(rinseItem.ModuleName))
                    {                        
                        rinses.Add(rinseItem.ModuleName);
                    }
                }
            }
            return rinses;
        }
    }
}