CyberX8/CyberX8_RT/Dispatch/DummyWaferManager.cs

using Aitex.Core.Common;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using CyberX8_RT.Modules.Dummy;
using CyberX8_RT.Modules;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MECF.Framework.Common.WaferHolder;
using Aitex.Core.RT.Fsm;
using CyberX8_RT.Modules.Buffer;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.RT.Core.Equipments;

namespace CyberX8_RT.Dispatch
{
    public class DummyWaferManager : Singleton<DummyWaferManager>
    {
        /// <summary>
        /// 加载工序完完毕的WaferHolder
        /// </summary>
        /// <returns></returns>
        public List<WaferHolderInfo> LoadCompletedWaferHolderInfo()
        {
            List<WaferHolderInfo> waferHolderInfos = new List<WaferHolderInfo>();
            List<string> dryerModules = DryerItemManager.Instance.InstalledModules;
            foreach (string item in dryerModules)
            {
                WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(item);
                if (waferHolderInfo == null)
                {
                    continue;
                }
                if (!Enum.TryParse(item, out ModuleName dryerModuleName))
                {
                    continue;
                }
                if (WaferHolderTaskManager.Instance.CheckWaferHolderNotExist(waferHolderInfo))
                {
                    if (WaferManager.Instance.CheckHasWafer(item, 0))
                    {
                        WaferInfo waferInfo = WaferManager.Instance.GetWafer(dryerModuleName, 0);
                        if (waferInfo != null && waferInfo.WaferType == WaferType.Production)
                        {
                            waferHolderInfos.Add(waferHolderInfo);
                            return waferHolderInfos;
                        }
                    }
                    if (WaferManager.Instance.CheckHasWafer(item, 1))
                    {
                        WaferInfo waferInfo = WaferManager.Instance.GetWafer(dryerModuleName, 1);
                        if (waferInfo != null &&waferInfo.WaferType == WaferType.Production)
                        {
                            waferHolderInfos.Add(waferHolderInfo);
                            return waferHolderInfos;
                        }
                    }
                }
            }
            List<string> installBufferModules = BufferItemManager.Instance.InstalledModules.ToList();
            foreach (string item in installBufferModules)
            {
                ModuleName moduleName=(ModuleName)Enum.Parse(typeof(ModuleName), item);
                BufferEntity bufferEntity = Singleton<RouteManager>.Instance.GetModule<BufferEntity>(item);
                if(bufferEntity==null)
                {
                    continue;
                }
                WaferHolderInfo waferHolderInfo=bufferEntity.WaferHolderInfo;
                if(waferHolderInfo==null)
                {
                    continue;
                }
                
                if(WaferManager.Instance.CheckHasWafer(item,0))
                {
                    WaferInfo waferInfo = WaferManager.Instance.GetWafer(moduleName, 0);
                    if(waferInfo!=null && waferInfo.ProcessState >= EnumWaferProcessStatus.InProcess&&waferInfo.WaferType==WaferType.Production)
                    {
                        waferHolderInfos.Add(waferHolderInfo);
                        continue;
                    }
                }
                if (WaferManager.Instance.CheckHasWafer(item, 1))
                {
                    WaferInfo waferInfo = WaferManager.Instance.GetWafer(moduleName, 1);
                    if (waferInfo != null && waferInfo.ProcessState >= EnumWaferProcessStatus.InProcess&&waferInfo.WaferType==WaferType.Production)
                    {
                        waferHolderInfos.Add(waferHolderInfo);
                    }
                }
            }
            return waferHolderInfos;
        }
        /// <summary>
        /// 通过WaferHolder加载DummyWafer
        /// </summary>
        /// <param name="waferHolderInfo"></param>
        /// <returns></returns>
        public List<WaferInfo> LoadDummyWafersByWaferHolder(WaferHolderInfo waferHolderInfo)
        {
            List<WaferInfo> waferInfos = new List<WaferInfo>();
            if(ModuleHelper.IsInstalled(ModuleName.Dummy1))
            {
                LoadDummyWaferByDummyModule(ModuleName.Dummy1,waferHolderInfo.Id, waferInfos);
            }
            if(ModuleHelper.IsInstalled(ModuleName.Dummy2))
            {
                LoadDummyWaferByDummyModule(ModuleName.Dummy2,waferHolderInfo.Id, waferInfos);
            }
            return waferInfos;
        }

        /// <summary>
        /// 通过Dummy模块加载DummyWafer
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="orginalModuleName"></param>
        /// <param name="waferInfos"></param>
        private void LoadDummyWaferByDummyModule(ModuleName dummyModuleName,string waferHolderId,List<WaferInfo> waferInfos)
        {
            DummyEntity dummyEntity = Singleton<RouteManager>.Instance.GetModule<DummyEntity>(dummyModuleName.ToString());
            if (dummyEntity == null)
            {
                return;
            }
            for (int i = 0; i < dummyEntity.MaxSlotNumber; i++)
            {
                if (WaferManager.Instance.CheckNoWafer(dummyModuleName, i))
                {
                    continue;
                }
                WaferInfo waferInfo = WaferManager.Instance.GetWafer(dummyModuleName, i);
                if (waferInfo == null)
                {
                    continue;
                }
                if (waferInfo.OrginalWaferHolder == waferHolderId)
                {
                    waferInfos.Add(waferInfo);
                }
            }
        }        
    }
}