CyberX8/Framework/Common/SubstrateTrackings/MaterialTrackerManager.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.EMMA;
using DocumentFormat.OpenXml.Vml;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.WaferHolder;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.SubstrateTrackings
{
    public class MaterialTrackerManager : Singleton<MaterialTrackerManager>
    {
        #region 内部变量
        /// <summary>
        /// 模块资源集合
        /// </summary>
        private List<ModuleMaterial> _moduleMaterials = new List<ModuleMaterial>();
        /// <summary>
        /// 模块资源(key-模块名称,value-资源)
        /// </summary>
        private Dictionary<string, ModuleMaterial> _moduleMaterialDic = new Dictionary<string, ModuleMaterial>();
        #endregion
        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            InitialModuleMaterial(ModuleName.PUF1.ToString());
            InitialModuleMaterial(ModuleName.PUF2.ToString());
            InitialModuleMaterial(ModuleName.Loader1.ToString());
            InitialModuleMaterial(ModuleName.Transporter2.ToString());
            InitialModuleMaterial(ModuleName.Transporter1.ToString());
            InitializeModulesMaterial(BufferItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(PrewetItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(DryerItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(MetalItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(RinseItemManager.Instance.InstalledModules);
            InitializeModulesMaterial(SrdItemManager.Instance.InstalledModules);
            InitializeData();
        }
        /// <summary>
        /// 初始化数据
        /// </summary>
        private void InitializeData()
        {
            DATA.Subscribe("System.ModuleMaterials", () => _moduleMaterials, SubscriptionAttribute.FLAG.IgnoreSaveDB);
        }
        /// <summary>
        /// 初始化Buffer模块
        /// </summary>
        private void InitializeModulesMaterial(List<string> lst)
        {
            foreach (string item in lst)
            {
                InitialModuleMaterial(item);
            }
        }
        /// <summary>
        /// 初始化模块资源
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitialModuleMaterial(string moduleName)
        {
            if (Enum.TryParse(moduleName, out ModuleName module))
            {
                if (ModuleHelper.IsInstalled(module))
                {
                    ModuleMaterial moduleMaterial = new ModuleMaterial();
                    moduleMaterial.ModuleName = moduleName;
                    moduleMaterial.SideAWaferType = "";
                    moduleMaterial.SideBWaferType = "";
                    UpdateModuleMaterial(moduleMaterial, moduleName);
                    _moduleMaterialDic[moduleName] = moduleMaterial;
                    _moduleMaterials.Add(moduleMaterial);
                }
            }
        }
        /// <summary>
        /// 是否WaferHolder模块
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        private bool IsModuleWaferHolder(ModuleName moduleName)
        {
            if(ModuleHelper.IsRinse(moduleName))
            {
                return true;
            }
            if (ModuleHelper.IsMetal(moduleName))
            {
                return true;
            }
            if (ModuleHelper.IsDry(moduleName))
            {
                return true;
            }
            if (ModuleHelper.IsBuffer(moduleName))
            {
                return true;
            }
            if (moduleName == ModuleName.Transporter1 || moduleName == ModuleName.Transporter2 || 
                    moduleName == ModuleName.Loader1||moduleName==ModuleName.Prewet1)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 更新模块资源
        /// </summary>
        public void UpdateModuleMaterial(string moduleName)
        {
            if (moduleName == "Loader")
            {
                moduleName = ModuleName.Loader1.ToString();
            }
            if (_moduleMaterialDic.ContainsKey(moduleName))
            {
                ModuleMaterial moduleMaterial = _moduleMaterialDic[moduleName];
                UpdateModuleMaterial(moduleMaterial,moduleName);
            }
        }
        /// <summary>
        /// 更新模块资源
        /// </summary>
        /// <param name="moduleMaterial"></param>
        /// <param name="moduleName"></param>
        private void UpdateModuleMaterial(ModuleMaterial moduleMaterial,string moduleName)
        {
            if (Enum.TryParse(moduleName, out ModuleName module))
            {
                if (IsModuleWaferHolder(module))
                {
                    WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(moduleName);
                    if (waferHolderInfo != null)
                    {
                        moduleMaterial.WaferHolderId = waferHolderInfo.Id;
                        if(WaferManager.Instance.CheckHasWafer(module,0))
                        {
                            WaferInfo info = WaferManager.Instance.GetWafer(module, 0);
                            moduleMaterial.SideAWaferStatus = WaferStatusConverter(info);
                            moduleMaterial.SideAWaferId = waferHolderInfo.WaferAId;
                            WaferType waferType = (WaferType)waferHolderInfo.WaferAType;
                            moduleMaterial.SideAWaferType = waferType.ToString();
                        }
                        else
                        {
                            moduleMaterial.SideAWaferStatus = (int)WaferStatus.Empty;
                            moduleMaterial.SideAWaferId = "";
                            moduleMaterial.SideAWaferType = "";
                        }
                        if (WaferManager.Instance.CheckHasWafer(module, 1))
                        {
                            WaferInfo info = WaferManager.Instance.GetWafer(module, 1);
                            moduleMaterial.SideBWaferStatus = WaferStatusConverter(info);
                            moduleMaterial.SideBWaferId = waferHolderInfo.WaferBId;
                            WaferType waferType = (WaferType)waferHolderInfo.WaferBType;
                            moduleMaterial.SideBWaferType = waferType.ToString();
                        }
                        else
                        {
                            moduleMaterial.SideBWaferStatus = (int)WaferStatus.Empty;
                            moduleMaterial.SideBWaferId = "";
                            moduleMaterial.SideBWaferType = "";
                        }
                    }
                    else
                    {
                        moduleMaterial.WaferHolderId = "";
                        moduleMaterial.SideAWaferId = "";
                        moduleMaterial.SideBWaferId = "";
                        moduleMaterial.SideAWaferType = "";
                        moduleMaterial.SideBWaferType = "";
                        moduleMaterial.SideAWaferStatus = (int)WaferStatus.Empty;
                        moduleMaterial.SideBWaferStatus = (int)WaferStatus.Empty;
                        return;
                    }
                }
                else
                {
                    moduleMaterial.WaferHolderId = "";
                    if (WaferManager.Instance.CheckHasWafer(module, 0))
                    {
                        WaferInfo waferAInfo = WaferManager.Instance.GetWafer(module, 0);
                        moduleMaterial.SideAWaferStatus = WaferStatusConverter(waferAInfo);
                        moduleMaterial.SideAWaferId = waferAInfo.WaferID;
                        moduleMaterial.SideAWaferType = waferAInfo.WaferType.ToString();
                    }
                    else
                    {
                        moduleMaterial.SideAWaferStatus = (int)WaferStatus.Empty;
                        moduleMaterial.SideAWaferId = "";
                        moduleMaterial.SideAWaferType = "";
                    }
                    if (WaferManager.Instance.CheckHasWafer(module, 1))
                    {
                        WaferInfo waferBInfo = WaferManager.Instance.GetWafer(module, 1);
                        moduleMaterial.SideBWaferStatus = WaferStatusConverter(waferBInfo);
                        moduleMaterial.SideBWaferId = waferBInfo.WaferID;
                        moduleMaterial.SideBWaferType = waferBInfo.WaferType.ToString();
                    }
                    else
                    {
                        moduleMaterial.SideBWaferStatus = (int)WaferStatus.Empty;
                        moduleMaterial.SideBWaferId = "";
                        moduleMaterial.SideBWaferType = "";
                    }
                }
                
            }
        }

        /// <summary>
        /// WaferStatus color converter
        /// 
        /// </summary>
        /// <param name="awafer"></param>
        /// <returns></returns>
        private int WaferStatusConverter(WaferInfo awafer)
        {
            //if (awafer.Status == WaferStatus.Empty)
            //    return 0;

            //if (awafer.Status == WaferStatus.Normal)
            //{
            //    switch (awafer.ProcessState)
            //    {
            //        case EnumWaferProcessStatus.InProcess: return 3;
            //        case EnumWaferProcessStatus.Completed: return 4;
            //        case EnumWaferProcessStatus.Failed: return 5;
            //        case EnumWaferProcessStatus.Idle: return awafer.ProcessJob == null ? 1 : 2;
            //    }
            //}

            //if (awafer.Status == WaferStatus.Dummy)
            //{
            //    return 1;
            //}

            //return 5;
            if (awafer.Status == WaferStatus.Empty)
                return 0;
            if (awafer.Status == WaferStatus.Normal)
            {
                if (awafer.WaferType == WaferType.Assit)
                {
                    return 6;
                }
                else
                {
                    switch (awafer.ProcessState)
                    {
                        case EnumWaferProcessStatus.InProcess: return 3;
                        case EnumWaferProcessStatus.Completed: return 4;
                        case EnumWaferProcessStatus.Failed: return 5;
                        case EnumWaferProcessStatus.Idle:
                            return awafer.ProcessJob == null ? 1 : 2;
                        case EnumWaferProcessStatus.Canceled:
                            return 7;
                        case EnumWaferProcessStatus.MisProcessed:
                            return 8;
                        case EnumWaferProcessStatus.MisSrdProcess:
                            return 9;
                    }
                }
            }

            if (awafer.Status == WaferStatus.Dummy)
            {
                return 6;
            }
            return 1;
        }
    }
}