PunkHPX8/PunkHPX8_RT/Schedulers/SchedulerSequenceManager.cs

using MECF.Framework.Common.RecipeCenter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using Aitex.Core.Common;
using MECF.Framework.Common.CommonData;
using System.Windows;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Routine;
using PunkHPX8_RT.Modules;
using Aitex.Core.RT.Fsm;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.RT.Core.Equipments;
using MECF.Framework.Common.ProcessCell;
using SecsGem.Core.ItemModel;
using PunkHPX8_RT.Modules.Transporter;
using PunkHPX8_Core;
using Aitex.Core.RT.SCCore;
using PunkHPX8_RT.Modules.SRD;
using PunkHPX8_RT.Devices.EFEM;
using Aitex.Sorter.Common;
using PunkHPX8_RT.Modules.Reservoir;
using PunkHPX8_RT.Modules.PlatingCell;

namespace PunkHPX8_RT.Schedulers
{
    public class SchedulerSequenceManager : Singleton<SchedulerSequenceManager>   
    {
        #region 常量 
        private const string ENGINEERING = "Engineering";
        private const string PRODUCTION = "Production";
        private const string TRNPA = "TRNPA";
        private const string TRNPB = "TRNPB";
        #endregion
        /// <summary>
        /// 解析Wafer所有调度工序
        /// </summary>
        /// <param name="sequenceRecipe"></param>
        /// <returns></returns>
        public List<SchedulerSequence> AnalyWaferAllSchedulerSequence(WaferInfo waferInfo, SequenceRecipe sequenceRecipe)
        {
            List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
            int index = 0;
            MoveItem moveItem = new MoveItem((ModuleName)waferInfo.OriginStation, waferInfo.OriginSlot, ModuleName.Aligner1, 0, 
                Hand.Blade1,Flip.Upper,Flip.Upper);
            SchedulerSequence efemRobotSequence = CreateEfemRobotSequence(moveItem, null, sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(efemRobotSequence);
            SchedulerSequence alignerSequence = CreateAlignerSequence(sequenceRecipe, ref index);
            schedulerSequences.Add(alignerSequence);
            //解析sequence recipe后续的工序
            var sequences = AnalyseSequenceRecipeScheduler(sequenceRecipe,false);
            if (sequences.Count == 0)
            {
                return schedulerSequences;
            }
            SchedulerSequence firstSequence = sequences[0];
            if (firstSequence.ModuleType != ModuleType.VPW)
            {
                return schedulerSequences;
            }
            MoveItem alignerToFirstMoveItem = new MoveItem();
            alignerToFirstMoveItem.SourceModule = ModuleName.Aligner1;
            alignerToFirstMoveItem.SourceSlot = 0;
            alignerToFirstMoveItem.DestinationType = firstSequence.ModuleType;
            alignerToFirstMoveItem.DestinationSlot = 0;
            alignerToFirstMoveItem.RobotHand = Hand.Blade1;
            alignerToFirstMoveItem.PickRobotFlip = Flip.Upper;
            alignerToFirstMoveItem.PlaceRobotFlip = Flip.Upper;
            SchedulerSequence alignerToFirstSequence = CreateEfemRobotSequence(moveItem, null, sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(efemRobotSequence);
            //调整工序后面的索引
            foreach (SchedulerSequence item in sequences)
            {
                item.SequenceIndex = index;
                index++;
            }
            schedulerSequences.AddRange(sequences);

            //若经过srd
            if (SequenceRecipeManager.Instance.IsContainedSrd(sequenceRecipe))
            {
                SrdRecipe srdRecipe = SequenceRecipeManager.Instance.GetSrdRecipeBySequenceRecipe(sequenceRecipe);
                if (srdRecipe != null)
                {
                    //从VPW取至SRD
                    MoveItem lastToSrdItem = new MoveItem();
                    lastToSrdItem.SourceModule = ModuleName.Unknown;
                    //A面
                    lastToSrdItem.SourceSlot = 0;
                    lastToSrdItem.SourceType = ModuleType.VPW;
                    lastToSrdItem.DestinationType = ModuleType.SRD;
                    lastToSrdItem.SourceSlot = 0;
                    lastToSrdItem.DestinationModule = ModuleName.Unknown;
                    lastToSrdItem.RobotHand = Hand.Blade1;
                    lastToSrdItem.PickRobotFlip = Flip.Upper;
                    lastToSrdItem.PlaceRobotFlip = Flip.Upper;
                    SchedulerSequence lastToSrdSequence = CreateEfemRobotSequence(lastToSrdItem, null,sequenceRecipe.SubstrateSize, ref index);
                    schedulerSequences.Add(lastToSrdSequence);
                    SchedulerSequence srdSequence = CreateSRDSequence(srdRecipe, ref index);
                    schedulerSequences.Add(srdSequence);
                    //SRD完成后回至LoadPort
                    MoveItem srdToLoadPortItem = new MoveItem();
                    srdToLoadPortItem.SourceModule = ModuleName.Unknown;
                    srdToLoadPortItem.SourceType = ModuleType.SRD;
                    srdToLoadPortItem.SourceSlot = 0;
                    srdToLoadPortItem.DestinationType = ModuleType.LoadPort;
                    srdToLoadPortItem.DestinationModule = (ModuleName)waferInfo.OriginStation;
                    srdToLoadPortItem.DestinationSlot = waferInfo.OriginSlot;
                    srdToLoadPortItem.RobotHand = Hand.Blade1;
                    lastToSrdItem.PickRobotFlip = Flip.Upper;
                    lastToSrdItem.PlaceRobotFlip = Flip.Upper;
                    SchedulerSequence srdToLoadPortSequence = CreateEfemRobotSequence(srdToLoadPortItem, null,sequenceRecipe.SubstrateSize, ref index);
                    schedulerSequences.Add(srdToLoadPortSequence);
                }
                else
                {
                    LOG.WriteBackgroundLog(eEvent.ERR_SEQUENCE, "System", $"{sequenceRecipe.Ppid} srd recipe is invalid");
                    return new List<SchedulerSequence>();
                }
            }
            else
            {
                //若无SRD，直接从VPW转LoadPort
                MoveItem srdToLoadPortItem = new MoveItem();
                srdToLoadPortItem.SourceModule = ModuleName.Unknown;
                srdToLoadPortItem.SourceType = ModuleType.VPW;
                srdToLoadPortItem.SourceSlot = 0;
                srdToLoadPortItem.DestinationType = ModuleType.LoadPort;
                srdToLoadPortItem.DestinationModule = (ModuleName)waferInfo.OriginStation;
                srdToLoadPortItem.DestinationSlot = waferInfo.OriginSlot;
                srdToLoadPortItem.RobotHand = Hand.Blade1;
                srdToLoadPortItem.PickRobotFlip = Flip.Upper;
                srdToLoadPortItem.PlaceRobotFlip = Flip.Upper;
                SchedulerSequence pufToLoaderSequence = CreateEfemRobotSequence(srdToLoadPortItem, null,sequenceRecipe.SubstrateSize, ref index);
                schedulerSequences.Add(pufToLoaderSequence);
            }
            return schedulerSequences;
        }
        /// <summary>
        /// 解析Dummy Wafer所有调度工序
        /// </summary>
        /// <param name="sequenceRecipe"></param>
        /// <returns></returns>
        public List<SchedulerSequence> AnalyDummyWaferAllSchedulerSequence(SequenceRecipe sequenceRecipe,WaferInfo waferInfo)
        {
            List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
            int index = 0;
            MoveItem moveItem = new MoveItem((ModuleName)waferInfo.OriginStation, waferInfo.OriginSlot, ModuleName.Aligner1, 0,
                Hand.Blade1, Flip.Upper, Flip.Upper);
            SchedulerSequence efemRobotSequence = CreateEfemRobotSequence(moveItem, null, sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(efemRobotSequence);
            SchedulerSequence alignerSequence = CreateAlignerSequence(sequenceRecipe, ref index);
            schedulerSequences.Add(alignerSequence);
            //解析sequence recipe后续的工序
            var sequences = AnalyseSequenceRecipeScheduler(sequenceRecipe, false);
            if (sequences.Count == 0)
            {
                return schedulerSequences;
            }
            SchedulerSequence firstSequence = sequences[0];
            if (firstSequence.ModuleType != ModuleType.VPW)
            {
                return schedulerSequences;
            }
            SchedulerSequence lastSequence=sequences[sequences.Count - 1];
            MoveItem alignerToFirstMoveItem = new MoveItem();
            alignerToFirstMoveItem.SourceModule = ModuleName.Aligner1;
            alignerToFirstMoveItem.SourceSlot = 0;
            alignerToFirstMoveItem.DestinationType = firstSequence.ModuleType;
            alignerToFirstMoveItem.DestinationSlot = 0;
            alignerToFirstMoveItem.RobotHand = Hand.Blade1;
            alignerToFirstMoveItem.PickRobotFlip = Flip.Upper;
            alignerToFirstMoveItem.PlaceRobotFlip = Flip.Upper;
            SchedulerSequence alignerToFirstSequence = CreateEfemRobotSequence(moveItem, null, sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(efemRobotSequence);
            //调整工序后面的索引
            foreach (SchedulerSequence item in sequences)
            {
                item.SequenceIndex = index;
                index++;
            }
            schedulerSequences.AddRange(sequences);

            //若无SRD，直接从VPW转LoadPort
            MoveItem srdToLoadPortItem = new MoveItem();
            srdToLoadPortItem.SourceModule = ModuleName.Unknown;
            srdToLoadPortItem.SourceType = lastSequence.ModuleType;
            srdToLoadPortItem.SourceSlot = 0;
            srdToLoadPortItem.DestinationType = ModuleType.Dummy;
            srdToLoadPortItem.DestinationModule = (ModuleName)waferInfo.OriginStation;
            srdToLoadPortItem.DestinationSlot = waferInfo.OriginSlot;
            srdToLoadPortItem.RobotHand = Hand.Blade1;
            srdToLoadPortItem.PickRobotFlip = Flip.Upper;
            srdToLoadPortItem.PlaceRobotFlip = Flip.Upper;
            SchedulerSequence toDummySequence = CreateEfemRobotSequence(srdToLoadPortItem, null, sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(toDummySequence);
            return schedulerSequences;
        }
        /// <summary>
        /// 分析Sequence recipe对应的调度步骤
        /// </summary>
        /// <param name="sequenceRecipe"></param>
        /// <returns></returns>
        private List<SchedulerSequence> AnalyseSequenceRecipeScheduler(SequenceRecipe sequenceRecipe,bool isDummy)
        {
            List<SchedulerSequence> schedulerSequences= new List<SchedulerSequence>();
            List<SchedulerSequence> tmpLst = new List<SchedulerSequence>();
            var  processResult = AnalyseLastProcessRecipeIndex(sequenceRecipe.Recipes);
            bool isExistSrd = sequenceRecipe.Recipes.FindIndex(O=>O.ToLower().EndsWith("srd.rcp"))!=-1;
            int lastIndex = isExistSrd ? sequenceRecipe.Recipes.Count - 2 : sequenceRecipe.Recipes.Count - 1;
            for(int i=0;i<sequenceRecipe.Recipes.Count;i++)
            {                
                string item = sequenceRecipe.Recipes[i];
                if(item.ToLower().EndsWith("srd.rcp"))//跳过SRD
                {
                    continue;
                }
                SchedulerSequence schedulerSequence = new SchedulerSequence();
                schedulerSequence.ModuleName = ModuleName.Unknown;
                schedulerSequence.ModuleType=SequenceRecipeManager.Instance.GetModuleType(item);
                schedulerSequence.SequenceIndex=i;
                schedulerSequence.WaferSize = sequenceRecipe.SubstrateSize;
                MECF.Framework.Common.RecipeCenter.RecipeType recipeType =SequenceRecipeManager.Instance.GetRecipeType(item);
                schedulerSequence.Recipe = SequenceRecipeManager.Instance.LoadSequenceTypeRecipe(sequenceRecipe.SequenceType,item, recipeType);
                schedulerSequence.SequenceType = sequenceRecipe.SequenceType;
                schedulerSequence.State = RState.Init;
                schedulerSequence.MaterialType = MaterialType.WaferHolder;
                tmpLst.Add(schedulerSequence); 
                if (i != lastIndex)
                {
                    string nextModule = sequenceRecipe.Recipes[i + 1];
                    schedulerSequence.NextModuleType = SequenceRecipeManager.Instance.GetModuleType(nextModule);
                    MECF.Framework.Common.RecipeCenter.RecipeType nextRecipeType = SequenceRecipeManager.Instance.GetRecipeType(nextModule);
                    schedulerSequence.NextRecipe = SequenceRecipeManager.Instance.LoadSequenceTypeRecipe(sequenceRecipe.SequenceType, nextModule, nextRecipeType);
                }
                schedulerSequence.IsProcessSequece = true;
                if(i==processResult.lastIndex)
                {
                    schedulerSequence.IsLastProcessSequence = true;
                }                
            }
            int index = 0;
            for(int i=0;i<tmpLst.Count;i++)
            {
                tmpLst[i].SequenceIndex = 0;
                schedulerSequences.Add(tmpLst[i]);
                index++;
                if (i < tmpLst.Count - 1)
                {
                    MoveItem moveItem = new MoveItem();
                    moveItem.SourceModule = tmpLst[i].ModuleName;
                    moveItem.SourceType = tmpLst[i].ModuleType;
                    moveItem.SourceSlot = 0;
                    moveItem.DestinationModule = tmpLst[i + 1].ModuleName;
                    moveItem.DestinationSlot = 0;
                    moveItem.DestinationType = tmpLst[i+1].ModuleType;
                    moveItem.RobotHand = Hand.Blade2;
                    //源来自于Plating cell，向下取
                    if (tmpLst[i].ModuleType == ModuleType.PlatingCell)
                    {
                        moveItem.PickRobotFlip = Flip.Down;
                    }
                    else
                    {
                        moveItem.PickRobotFlip = Flip.Upper;
                    }

                    //目标来自于Plating cell，向下放
                    if (tmpLst[i + 1].ModuleType == ModuleType.PlatingCell)
                    {
                        moveItem.PlaceRobotFlip = Flip.Down;
                    }
                    else
                    {
                        moveItem.PlaceRobotFlip = Flip.Upper;
                    }
                    SchedulerSequence robotSequence = CreateEfemRobotSequence(moveItem,null,sequenceRecipe.SubstrateSize, ref index);
                    schedulerSequences.Add(robotSequence);
                }
                else
                {
                    //生产片最后退至VPW中转
                    if (!isDummy)
                    {
                        MoveItem moveItem = new MoveItem();
                        moveItem.SourceModule = tmpLst[i].ModuleName;
                        moveItem.SourceType = tmpLst[i].ModuleType;
                        moveItem.SourceSlot = 0;
                        moveItem.DestinationModule = ModuleName.Unknown;
                        moveItem.DestinationSlot = 0;
                        moveItem.DestinationType = ModuleType.VPW;
                        moveItem.RobotHand = Hand.Blade2;
                        //源来自于Plating cell，向下取
                        if (tmpLst[i].ModuleType == ModuleType.PlatingCell)
                        {
                            moveItem.PickRobotFlip = Flip.Down;
                        }
                        else
                        {
                            moveItem.PickRobotFlip = Flip.Upper;
                        }
                        moveItem.PlaceRobotFlip = Flip.Upper;
                        SchedulerSequence robotSequence = CreateEfemRobotSequence(moveItem, null, sequenceRecipe.SubstrateSize, ref index);
                        schedulerSequences.Add(robotSequence);
                    }
                }
            }
            return schedulerSequences;
        }
        /// <summary>
        /// 分析最后加工recipe索引
        /// </summary>
        /// <param name="recipes"></param>
        /// <returns></returns>
        private (int lastIndex,List<int> processIndexList) AnalyseLastProcessRecipeIndex(List<string> recipes)
        {
            int index = 0;
            List<int> lst = new List<int>();
            for(int i=0;i<recipes.Count; i++)
            {
                string item=recipes[i];
                if(item.ToLower().EndsWith("dep.rcp"))
                {
                    index = i;
                    if(lst.Contains(i))
                    {
                        lst.Add(i);
                    }
                }
            }
            if(lst.Count==0)
            {
                lst.Add(0);
            }
            return (index,lst);
        }

        /// <summary>
        /// 创建EFEM Robot步骤
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreateEfemRobotSequence(MoveItem moveItem,List<SchedulerSyncModuleMessage> synModules,int waferSize,ref int index)
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.EfemRobot);
            sequence.SequenceIndex= index;
            sequence.ModuleName=ModuleName.EfemRobot;
            sequence.State = RState.Init;
            sequence.Recipe = null;
            sequence.ModuleType=ModuleType.EfemRobot;
            sequence.Parameters =moveItem;
            sequence.MaterialType = MaterialType.Wafer;
            sequence.SynchronousModuleMessages = synModules;
            sequence.WaferSize = waferSize;
            index++;
            return sequence;
        }
        /// <summary>
        /// 创建Aligner步骤 
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreateAlignerSequence(SequenceRecipe recipe,ref int index) 
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.Aligner1);
            sequence.SequenceIndex = index;
            sequence.ModuleName = ModuleName.Aligner1;
            sequence.State = RState.Init;
            sequence.Recipe = recipe;
            sequence.ModuleType = ModuleType.Aligner;
            sequence.Parameters = null;
            sequence.MaterialType = MaterialType.Wafer;
            sequence.WaferSize = sequence.WaferSize;
            index++;
            return sequence;
        }
        /// <summary>
        /// 创建Loader步骤
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreateSRDSequence(SrdRecipe recipe,ref int index)
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SequenceIndex = index;
            sequence.State = RState.Init;
            sequence.Recipe = recipe;
            sequence.ModuleType = ModuleType.SRD;
            sequence.MaterialType = MaterialType.Wafer;
            index++;
            return sequence;
        }

        /// <summary>
        /// 根据模块类型获取可用模块
        /// </summary>
        /// <param name="moduleType"></param>
        /// <returns></returns>
        public ModuleName GetAvaibleModuleCell(string sequenceType,ModuleType moduleType)
        {
                List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
                List<IModuleEntity> avaibles = new List<IModuleEntity>();
                foreach (var item in entities)
                {
                    bool result = CheckAvaibleModule(item,moduleType,sequenceType);
                    if (result)
                    {
                        avaibles.Add(item);
                    }
                }

                return GetMinTimeToReadyModule(avaibles,moduleType);
        }
        /// <summary>
        /// 根据化学液计算时间获取可用PlatingCellCell(参考其他PlatingCell剩余时间)
        /// </summary>
        /// <param name="chemistry"></param>
        /// <returns></returns>
        public (ModuleName platingCellModule, ModuleName rinseModule) CalculateAvaiblePlatingCellCellByChemistry(string chemistry, string startRinse, string sequenceType, string waferHolderId,
            int waferSize,DateTime startTime, int depRecipeTimeLength, int qdrRecipeTimeLength, bool checkConflict,
            SchedulerModulePartTime platingCellPartTime, SchedulerModulePartTime qdrParTime, ref bool isExistEnablePlatingCell)
        {
            bool isShowLog = SC.GetValue<bool>("Scheduler.IsShowLog");
            if (!Enum.TryParse(startRinse, out ModuleName startRinseModule) )
            {
                startRinse = "";
            }
            isExistEnablePlatingCell = false;
            return (ModuleName.Unknown, ModuleName.Unknown);
        }
        /// <summary>
        /// 根据化学液获取可用PlatingCell
        /// </summary>
        /// <param name="chemistry"></param>
        /// <param name="sequenceType"></param>
        /// <returns></returns>
        public bool CalculateAvaiblePlatingCellCellByChemistry(string chemistry,string sequenceType,int waferSize)
        {
            return false;
        }
        /// <summary>
        /// 检验Process transporter正在Transfer WH移动至Rinse
        /// </summary>
        /// <returns></returns>
        private bool CheckProcessTransporterTransfering(List<string> rinseList)
        {
            return false;
        }
        /// <summary>
        /// 计算PlatingCell所在Reservoir Busy PlatingCell数量
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        private (bool success,int busyCount) CalculatePlatingCellReservoirAllBusyPlatingCellCount(string platingCellName)
        {
            string reservoirName = ReservoirItemManager.Instance.GetReservoirByPlatingCell(platingCellName);
            if (string.IsNullOrEmpty(reservoirName))
            {
                return (false,0);
            }
            List<string> platingCells = ReservoirItemManager.Instance.GetPlatingCellsByReservoir(reservoirName);
            int count = 0;
            foreach (string item in platingCells)
            {
                if (platingCellName == item)
                {
                    continue;
                }
            }
            return (true,count);
        }
        /// <summary>
        /// 检验独立Rinse是否可用
        /// </summary>
        /// <param name="singleRinseItems"></param>
        /// <param name="platingCellName"></param>
        /// <returns></returns>
        private bool CheckSingleRinseItemsCanUsed(List<string> singleRinseItems, string platingCellName)
        {
            var result = CalculatePlatingCellReservoirAllBusyPlatingCellCount(platingCellName);
            if(result.success)
            {
                bool transporterTransfering = CheckProcessTransporterTransfering(singleRinseItems);
                if (transporterTransfering)
                {
                    return result.busyCount + 1 < singleRinseItems.Count;
                }
                else
                {
                    return result.busyCount < singleRinseItems.Count;
                }
            }
            return false;
        }
        /// <summary>
        /// 检验可用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="moduleType"></param>
        /// <param name="sequenceType"></param>
        /// <param name="waferHolderId"></param>
        /// <param name="startTime"></param>
        /// <param name="processLength"></param>
        /// <returns></returns>
        public bool CheckAvaiblePlatingCellModule(IModuleEntity item, ModuleType moduleType, string sequenceType, string waferHolderId, DateTime startTime, int processLength, bool checkConflict)
        {
            bool result = CheckAvaibleModule(item, moduleType, sequenceType);
            if (!result)
            {
                return false;
            }
            if (checkConflict)
            {
                var conflict = SchedulerPlatingCellTimeManager.Instance.CheckPlatingCellConflict(item.Module.ToString(), waferHolderId, startTime, processLength);
                return !conflict.conflict;
            }
            else
            {
                return result;
            }
        }
        /// <summary>
        /// 检验模块是否可用
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool CheckAvaibleModule(IModuleEntity item,ModuleType moduleType,string sequenceType)
        {
            if (item.IsDisable)
            {
                return false;
            }
            if (!item.IsAuto)
            {
                return false;
            }
            if (item.IsError)
            {
                return false;
            }
            if (item.IsInit)
            {
                return false;
            }
            if (moduleType==ModuleType.PlatingCell)
            {
                if(item.IsProduction && sequenceType == ENGINEERING)
                    return false;
                if (item.IsEngineering && sequenceType == PRODUCTION)
                    return false;
            }
            return true;
        }
        /// <summary>
        /// 获取剩余时间最小的模块
        /// </summary>
        /// <param name="avaibles"></param>
        /// <returns></returns>
        private ModuleName GetMinTimeToReadyModule(List<IModuleEntity> avaibles,ModuleType moduleType)
        {
            if (avaibles.Count == 1)
            {
                return avaibles[0].Module;
            }
            int timeToReady = int.MaxValue;
            IModuleEntity selectedModule = null;
            List<IModuleEntity> idleModuleEtities = new List<IModuleEntity>(); 
            foreach (var item in avaibles)
            {
                if (item.IsIdle)
                {
                    if(moduleType!=ModuleType.PlatingCell)
                    {
                        return item.Module;
                    }
                    idleModuleEtities.Add(item);
                }
                if (item.TimeToReady < timeToReady&&idleModuleEtities.Count==0)
                {
                    timeToReady = item.TimeToReady;
                    selectedModule = item;
                }
            }
            if (idleModuleEtities.Count != 0)
            {
                return GetMinUsagePlatingCell(idleModuleEtities);
            }
            if (selectedModule != null)
            {
                return selectedModule.Module;
            }
            return ModuleName.Unknown;
        }
        /// <summary>
        /// 获取电量最小的PlatingCell
        /// </summary>
        /// <param name="idleModuleEntities"></param>
        /// <returns></returns>
        private ModuleName GetMinUsagePlatingCell(List<IModuleEntity> idleModuleEntities, int depProcessLength, SchedulerModulePartTime platingCellPartTime)
        {
            ModuleName selectedModuleName = ModuleName.Unknown;
            List<string> minDateModuleLst = new List<string>();
            return selectedModuleName;
        }
        /// <summary>
        /// 获取电量最小的PlatingCell
        /// </summary>
        /// <param name="idleModuleEntities"></param>
        /// <returns></returns>
        private ModuleName GetMinUsagePlatingCell(List<IModuleEntity> idleModuleEntities)
        {
            ModuleName selectedModuleName = ModuleName.Unknown;
            return selectedModuleName;
        }
        /// <summary>
        /// 获取PlatingCell可用的Rinse模块
        /// </summary>
        /// <param name="platingCellName"></param>
        /// <returns></returns>
        private ModuleName GetPlatingCellAvaibleRinseModule(List<IModuleEntity> items, ModuleName platingCellName)
        {
            int platingCellId = CellItemManager.Instance.GetCellIdByModuleName(platingCellName.ToString());
            if (platingCellId == 0)
            {
                return ModuleName.Unknown;
            }
            List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByPlatingCell(platingCellName.ToString());
            if (rinseItems.Count == 0)
            {
                return ModuleName.Unknown;
            }

            return ModuleName.Unknown;
        }

        /// <summary>
        /// 根据化学液获取可用的PlatingCell集合
        /// </summary>
        /// <param name="chemistry"></param>
        /// <returns></returns>
        public List<PlatingCellEntity> GetAvaiblePlatingCellList(string chemistry, string sequenceType, bool isEmpty)
        {
            List<IModuleEntity> reservoirEntities = Singleton<RouteManager>.Instance.GetModulesByModuleType(ModuleType.Reservoir);
            List<string> avaibles = new List<string>();
            foreach (IModuleEntity item in reservoirEntities)
            {
                ReservoirEntity entity = item as ReservoirEntity;
                if (entity.Chemistry == chemistry && entity.IsAuto && entity.IsInitialized)
                {
                    avaibles.Add(entity.Module.ToString());
                }
            }

            List<PlatingCellEntity> metals = new List<PlatingCellEntity>();
            foreach (string item in avaibles)
            {
                ReservoirItem reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(item);
                if (reservoirItem == null)
                {
                    continue;
                }
                foreach (PlatingCellItem subItem in reservoirItem.PlatingCells)
                {
                    PlatingCellEntity entity = Singleton<RouteManager>.Instance.GetModule<PlatingCellEntity>($"PlatingCell{subItem.PlatingCellID}");
                    if (!CheckAvaibleModule(entity, ModuleType.PlatingCell, sequenceType))
                    {
                        continue;
                    }
                    if (!isEmpty || (isEmpty && entity.WaferInfo == null))
                    {
                        metals.Add(entity);
                    }
                }
            }
            return metals;
        }
    }


}