Kepler-Release/Venus/Venus_RT/Modules/AutoCycle.cs

using System;
using System.Collections.Generic;
using System.Linq;

using Aitex.Core.Common;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.RT.Fsm;

using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.DBCore;

using Venus_Core;

using Venus_RT.Modules.Schedulers;
using Venus_RT.Scheduler;
using Venus_Unity;

namespace Venus_RT.Modules
{
    enum ModulePriority
    {
        High,
        Middle,
        Low,
        Stop,
    }

    public enum MovingStatus
    {
        Idle,
        Waiting,
        Moving,

        // PM Status
        WaitProcess,
        StartProcess,
        Processing,
    }
    class ModuleFlag
    {
        public ModulePriority Priority { get; set; }
        public MovingStatus MovingStatus { get; set; }

        public ModuleFlag(ModulePriority _priority)
        {
            Priority = _priority;
            MovingStatus = MovingStatus.Idle;
        }
    }

    class AutoCycle : IRoutine
    {
        private List<ControlJobInfo> _lstControlJobs = new List<ControlJobInfo>();
        private List<ProcessJobInfo> _lstProcessJobs = new List<ProcessJobInfo>();

        private RState _cycleState = RState.Init;

        Dictionary<ModuleName, SchedulerModule> _atmSchedulers  = new Dictionary<ModuleName, SchedulerModule>();
        Dictionary<ModuleName, ModuleFlag> _atmModules          = new Dictionary<ModuleName, ModuleFlag>();

        Dictionary<ModuleName, SchedulerModule> _vacSchedulers  = new Dictionary<ModuleName, SchedulerModule>();
        Dictionary<ModuleName, ModuleFlag> _vacModules          = new Dictionary<ModuleName, ModuleFlag>();


        SchedulerTMRobot _tmRobot = (SchedulerTMRobot)Singleton<TransferModule>.Instance.GetScheduler(ModuleName.TMRobot);
        SchedulerEfemRobot _efemRobot = (SchedulerEfemRobot)Singleton<TransferModule>.Instance.GetScheduler(ModuleName.EfemRobot);

        List<SlotItem>  _vacReadyOutSlots   = new List<SlotItem>();
        List<SlotItem>  _vacReadyInSlots    = new List<SlotItem>();
        List<SlotItem>  _atmReadyOutSlots   = new List<SlotItem>();
        List<SlotItem>  _atmReadyInSlots    = new List<SlotItem>();

        List<int> _LLAInSlot = new List<int> { 0, 1, 2, 3 };
        List<int> _LLAOutSlot = new List<int> { 0, 1, 2, 3 };
        List<int> _LLBInSlot = new List<int> { 0, 1, 2, 3 };
        List<int> _LLBOutSlot = new List<int> { 0, 1, 2, 3 };
        int _LLASlotNumber = 4;
        int _LLBSlotNumber = 4;

        List<MoveItem> _movingItems = new List<MoveItem>();
        List<MoveItem> _efemMovingItems = new List<MoveItem>();

        Dictionary<SlotItem, Guid> _vacWaferTargets = new Dictionary<SlotItem, Guid>();
        Dictionary<SlotItem, Guid> _atmWaferTargets = new Dictionary<SlotItem, Guid>();

        R_TRIG _vacMoveFinishTrig = new R_TRIG();
        R_TRIG _atmMoveFinishTrig = new R_TRIG();

        private SchedulerFACallback _faCallback;
        private SchedulerDBCallback _dbCallback;

        private bool _isCycleMode;
        private int _cycleSetPoint = 0;
        private int _cycledCount = 0;
        private int _cycledWafer = 0;
        public bool HasJobRunning => _lstControlJobs.Count > 0;

        #region public interface
        public AutoCycle() 
        {
            _faCallback = new SchedulerFACallback();
            _dbCallback = new SchedulerDBCallback();

            InitModules();

            _LLASlotNumber = SC.GetValue<int>("LLA.SlotNumber");
            _LLBSlotNumber = SC.GetValue<int>("LLB.SlotNumber");

            _LLAInSlot.RemoveAll(item => item >= _LLASlotNumber);
            _LLAOutSlot.RemoveAll(item => item >= _LLASlotNumber);

            _LLBInSlot.RemoveAll(item => item >= _LLBSlotNumber);
            _LLBOutSlot.RemoveAll(item => item >= _LLBSlotNumber);

            DATA.Subscribe("Scheduler.CycledCount", () => _cycledCount);
            DATA.Subscribe("Scheduler.CycledWafer", () => _cycledWafer);
            DATA.Subscribe("Scheduler.CycleSetPoint", () => _cycleSetPoint);


            DATA.Subscribe("Scheduler.PjIdList", () => Array.ConvertAll(_lstProcessJobs.ToArray(), x => x.InnerId.ToString()).ToList());
        }

        public RState Start(params object[] objs)
        {
            _isCycleMode = SC.GetValue<bool>("System.IsCycleMode");
            _cycleSetPoint = _isCycleMode ? SC.GetValue<int>("System.CycleCount") : 0;
            _cycledWafer = 0;
            _cycledCount = 0;

            return RState.Running;
        }

        public RState Monitor()
        {
            prelude();
            driveAtmSystem();
            driveVacSystem();
            epilogue();
            return _cycleState;
        }

        public void Abort()
        {
        }

        public void CreateJob(Dictionary<string, object> param)
        {
            _isCycleMode = SC.GetValue<bool>("System.IsCycleMode");
            _cycleSetPoint = _isCycleMode ? SC.GetValue<int>("System.CycleCount") : 0;


            string[] slotSequence = (string[])param["SlotSequence"];
            string jobId = (string)param["JobId"];
            string module = (string)param["Module"];
            //bool autoStart = (bool)param["AutoStart"];
            string lotId = jobId;
            if (param.ContainsKey("LotId"))
                lotId = (string)param["LotId"];

            if (slotSequence.Length != SC.GetValue<int>("EFEM.LoadPort.SlotNumber"))
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"slot sequence parameter not valid, length is {slotSequence.Length}, should be {SC.GetValue<int>("EFEM.LoadPort.SlotNumber")}");
                _faCallback.JobCreateFailed(module, lotId, jobId, "");
                return;
            }

            if (!ModuleHelper.IsLoadPort(ModuleHelper.Converter(module)))
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"{module} should be LoadPort");
                _faCallback.JobCreateFailed(module, lotId, jobId, "");
                return;
            }

            if (string.IsNullOrEmpty(jobId))
            {
                jobId = "CJ_Local_" + module;
            }

            if (_lstControlJobs.Exists(x => x.Name == jobId))
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"{jobId} already created");
                _faCallback.JobCreateFailed(module, lotId, jobId, "");
                return;
            }

            SchedulerLoadPort lp = _atmSchedulers[ModuleHelper.Converter(module)] as SchedulerLoadPort;
            if (!lp.CheckReadyRunJob())
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"{module} not ready");
                _faCallback.JobCreateFailed(module, lotId, jobId, "");
                return;
            }

            ControlJobInfo cj = new ControlJobInfo();
            cj.Name = jobId;
            cj.Module = module;
            cj.LotName = lotId;
            cj.LotInnerId = Guid.NewGuid();
            cj.LotWafers = new List<WaferInfo>();
            cj.SetState(EnumControlJobState.WaitingForStart);

            Dictionary<string, bool[]> seqSlot = new Dictionary<string, bool[]>();
            Dictionary<string, List<Tuple<ModuleName, int>>> seqSlotWafers = new Dictionary<string, List<Tuple<ModuleName, int>>>();
            Dictionary<string, string> indexSequence = new Dictionary<string, string>();

            bool enableGroupBySequence = SC.GetValue<bool>("Scheduler.GroupWaferBySequence");
            for (int i = 0; i < SC.GetValue<int>("EFEM.LoadPort.SlotNumber"); i++)
            {
                if (string.IsNullOrEmpty(slotSequence[i]) || string.IsNullOrEmpty(slotSequence[i].Trim()))
                    continue;

                string groupName = enableGroupBySequence ? slotSequence[i].Trim() : i.ToString();
                indexSequence[groupName] = slotSequence[i];
                if (!seqSlot.ContainsKey(groupName))
                {
                    seqSlot[groupName] = new bool[SC.GetValue<int>("EFEM.LoadPort.SlotNumber")];
                }
                if (!seqSlotWafers.ContainsKey(groupName))
                {
                    seqSlotWafers[groupName] = new List<Tuple<ModuleName, int>>();
                }
                seqSlot[groupName][i] = true;

                if (!WaferManager.Instance.CheckHasWafer(module, i))
                {
                    LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"job wafer: {module} slot {i + 1} not in the carrier");
                    return;
                }
                if (!WaferManager.Instance.CheckWafer(ModuleHelper.Converter(module), i, WaferStatus.Normal))
                {
                    LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"job wafer: {module} slot {i + 1} status is {WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), i).Status}");
                    _faCallback.JobCreateFailed(module, lotId, jobId, "");
                    return;
                }

                if (WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), i).ProcessState != EnumWaferProcessStatus.Idle)
                {
                    LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"job wafer: {module} slot {i + 1} process status is {WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), i).ProcessState}");
                    _faCallback.JobCreateFailed(module, lotId, jobId, "");
                    return;
                }

                cj.LotWafers.Add(WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), i));
                WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), i).SequenceName = slotSequence[i];

                seqSlotWafers[groupName].Add(Tuple.Create(ModuleHelper.Converter(module), i));

                cj.JobWaferSize = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), i).Size;

                LOG.Write(eEvent.EV_ROUTER, ModuleName.System, $"Assigned wafer job, wafer {module}.{i + 1}, sequence: {slotSequence[i]}");
            }

            if (seqSlotWafers.Count == 0)
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"job has not assign wafer");
                _faCallback.JobCreateFailed(module, lotId, jobId, "");
                return;
            }

            List<ProcessJobInfo> pjs = new List<ProcessJobInfo>();
            string[] seqs = seqSlot.Keys.ToArray();
            for (int i = 0; i < seqs.Length; i++)
            {
                ProcessJobInfo pj = new ProcessJobInfo();
                pj.Name = jobId + "_" + (i + 1);
                pj.Sequence = SequenceInfoHelper.GetInfo(indexSequence[seqs[i]]);
                pj.ControlJobName = cj.Name;
                pj.LotName = lotId;
                pj.SlotWafers = seqSlotWafers[seqs[i]];
                pj.SetState(EnumProcessJobState.Queued);

                if (!CheckSequencePmReady(pj.Sequence, null, out _, out string reason))
                {
                    LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"no valid chamber for the {reason}");
                    _faCallback.JobCreateFailed(module, lotId, jobId, "");
                    return;
                }

                if (!RouteManager.IsATMMode && !CheckSequenceRecipeFileValid(pj.Sequence, out reason))
                {
                    LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"recipe file not valid in the sequence, {reason}");
                    _faCallback.JobCreateFailed(module, lotId, jobId, "");
                    return;
                }

                pjs.Add(pj);
            }

            _dbCallback.LotUpdate(cj);
            foreach (var pj in pjs)
            {
                cj.ProcessJobNameList.Add(pj.Name);
                _lstProcessJobs.Add(pj);
            }

            _lstControlJobs.Add(cj);
            //AssociatedPMWithLP(cj);

            _faCallback.JobCreated(cj, GetFirstProcessJob(cj));
        }

        public bool CheckAllJobDone()
        {
            foreach (var cj in _lstControlJobs)
            {
                if (cj.State == EnumControlJobState.Executing || cj.State == EnumControlJobState.Paused)
                    return false;
            }

            return true;
        }

        public bool CheckJobJustDone(out string sJobName)
        {
            foreach (var cj in _lstControlJobs)
            {
                if (cj.State == EnumControlJobState.Completed && !cj.BeenPosted)
                {
                    //LP;WaferSize;Lot;Number;Start;End;
                    sJobName = $"{cj.Module};{cj.JobWaferSize};{cj.LotName};{cj.LotWafers.Count};{cj.StartTime:T};{cj.EndTime:T}";
                    cj.BeenPosted = true;
                    return true;
                }
            }

            sJobName = "NULL";
            return false;
        }

        public ProcessJobInfo GetFirstProcessJob(ControlJobInfo cj)
        {
            foreach (var pj in _lstProcessJobs)
            {
                if (pj.ControlJobName == cj.Name)
                    return pj;
            }

            return null;
        }
        public void AbortJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"abort job rejected, not found job with id {jobName}");
                return;
            }

            List<ProcessJobInfo> pjAbortList = new List<ProcessJobInfo>();
            foreach (var pj in _lstProcessJobs)
            {
                if (pj.ControlJobName == cj.Name)
                {
                    pj.SetState(EnumProcessJobState.Aborting);
                    pjAbortList.Add(pj);

                    int unprocessed = 0;
                    int aborted = 0;
                    WaferInfo[] wafers = WaferManager.Instance.GetWaferByProcessJob(pj.Name);
                    foreach (var waferInfo in wafers)
                    {
                        waferInfo.ProcessJob = null;
                        waferInfo.NextSequenceStep = 0;
                        if (waferInfo.ProcessState != EnumWaferProcessStatus.Completed)
                            unprocessed++;
                    }
                    JobDataRecorder.EndPJ(pj.InnerId.ToString(), aborted, unprocessed);
                }
            }

            _faCallback.JobAborted(cj, GetFirstProcessJob(cj));
            _dbCallback.LotFinished(cj);
            foreach (var pj in pjAbortList)
            {
                _lstProcessJobs.Remove(pj);
            }

            _lstControlJobs.Remove(cj);
        }

        public void StopJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"stop job rejected, not found job with id {jobName}");
                return;
            }

            foreach (var pj in _lstProcessJobs)
            {
                if (pj.ControlJobName == cj.Name)
                {
                    pj.SetState(EnumProcessJobState.Stopping);
                }
            }

            _faCallback.JobStopped(cj, GetFirstProcessJob(cj));
            _dbCallback.LotFinished(cj);
        }
        public void ResumeJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"resume job rejected, not found job with id {jobName}");
                return;
            }

            if (cj.State == EnumControlJobState.Paused)
            {
                cj.SetState(EnumControlJobState.Executing);
            }

            _faCallback.JobResumed(cj, GetFirstProcessJob(cj));
        }

        public void PauseJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"pause job rejected, not found job with id {jobName}");
                return;
            }

            if (cj.State == EnumControlJobState.Executing)
            {
                cj.SetState(EnumControlJobState.Paused);
            }
            _faCallback.JobPaused(cj, GetFirstProcessJob(cj));
        }


        public void StartJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                LOG.Write(eEvent.WARN_ROUTER, ModuleName.System, $"start job rejected, not found job with id {jobName}");
                return;
            }

            if (cj.State == EnumControlJobState.WaitingForStart)
            {
                cj.SetState(EnumControlJobState.Executing);
                //PreJobClean(cj);

                (_atmSchedulers[ModuleHelper.Converter(cj.Module)] as SchedulerLoadPort).NoteJobStart();

                cj.StartTime = DateTime.Now;

                _dbCallback.LotCreated(cj);
                _faCallback.JobStarted(cj, GetFirstProcessJob(cj));

                //if (!_blockingWatcher.IsRunning)
                //    _blockingWatcher.Restart();

                //ResetTraceFlag();
            }

            _cycleState = RState.Running;
        }

        public void Clear()
        {
            _efemRobot.ResetTask();
            _tmRobot.ResetTask();
            foreach (var module in _vacSchedulers)
            {
                module.Value.ResetTask();
            }

            foreach (var module in _atmSchedulers)
            {
                module.Value.ResetTask();
            }

            _lstControlJobs.Clear();
            _lstProcessJobs.Clear();

            //_mapTarget.Clear();

            //queMoveAction.Clear();
            //_curAction.state = ActionState.Done;
        }


        #endregion

        private void InitModules()
        {
            foreach(var module in new ModuleName[]{ ModuleName.LP1, ModuleName.LP2, ModuleName.LP3, 
                ModuleName.Aligner1, ModuleName.Aligner2, ModuleName.Cooling1, ModuleName.Cooling2})
            {
                if(ModuleHelper.IsInstalled(module))
                {
                    if(ModuleHelper.IsLoadPort(module))
                    {
                        _atmSchedulers[module] = Singleton<TransferModule>.Instance.GetScheduler(module);
                        _atmModules[module] = new ModuleFlag(ModulePriority.Middle);
                    }
                    else if(ModuleHelper.IsAligner(module) || ModuleHelper.IsCooling(module))
                    {
                        _atmSchedulers[module] = Singleton<TransferModule>.Instance.GetScheduler(module);
                        _atmModules[module] = new ModuleFlag(ModulePriority.Middle);
                    }
                }
            }

            foreach (var module in new ModuleName[] { ModuleName.PMA, ModuleName.PMB, ModuleName.PMC, 
                ModuleName.PMD, ModuleName.PME, ModuleName.PMF})
            {
                if (ModuleHelper.IsInstalled(module))
                {
                    _vacSchedulers[module] = Singleton<TransferModule>.Instance.GetScheduler(module);
                    _vacModules[module] = new ModuleFlag(ModulePriority.Middle);
                }
            }

            foreach (var module in new ModuleName[] { ModuleName.LLA, ModuleName.LLB })
            {
                if (ModuleHelper.IsInstalled(module))
                {
                    var llScheduler = Singleton<TransferModule>.Instance.GetScheduler(module);
                    _vacSchedulers[module] = llScheduler;
                    _vacModules[module] = new ModuleFlag(ModulePriority.Middle);

                    _atmSchedulers[module] = llScheduler;
                    _atmModules[module] = new ModuleFlag(ModulePriority.Middle);
                }
            }
        }

        private void prelude()
        {
        }

        private void epilogue()
        {
            CheckWaferArrived();
            ProcessPMTask();

            UpdateProcessJobStatus();
            UpdateControlJobStatus();
            StartNewJob();
        }

        private void driveVacSystem()
        {
            PumpingTMRobotTask();
            ProcessTMRobotTask();
            RuningTMRobotTask();
        }

        #region Vacuum System
        private void PumpingTMRobotTask()
        {
            if (!_tmRobot.IsAvailable)
                return;

            foreach(var mod in _vacSchedulers)
            {
                if (mod.Value.IsAvailable && _vacModules[mod.Key].MovingStatus == MovingStatus.Idle)
                {
                    if(ModuleHelper.IsLoadLock(mod.Key))
                    {
                        var inSlots = mod.Key == ModuleName.LLA ? _LLAInSlot : _LLBInSlot;
                        foreach(var slot in inSlots)
                        {
                            if (IsLoadLockReservedByEFEM(mod.Key))
                                continue;

                            if(WaferManager.Instance.CheckHasWafer(mod.Key, slot) && IsVacWaferReadyOut(mod.Key, slot))
                            {
                                _vacReadyOutSlots.Add(new SlotItem(mod.Key, slot));
                            }
                        }

                        var outSlots = mod.Key == ModuleName.LLA ? _LLAOutSlot : _LLBOutSlot;
                        foreach(var slot in outSlots)
                        {
                            if (IsLoadLockReservedByEFEM(mod.Key))
                                continue;

                            if (WaferManager.Instance.CheckNoWafer(mod.Key, slot))
                            {
                                _vacReadyInSlots.Add(new SlotItem(mod.Key, slot));
                            }
                        }
                    }
                    else
                    {
                        if(WaferManager.Instance.CheckHasWafer(mod.Key, 0) && IsVacWaferReadyOut(mod.Key, 0))  // processed?
                        {
                            _vacReadyOutSlots.Add(new SlotItem(mod.Key, 0));
                        }
                        else if(WaferManager.Instance.CheckNoWafer(mod.Key, 0))
                        {
                            _vacReadyInSlots.Add(new SlotItem(mod.Key, 0));
                        }
                    }
                }
            }
        }

        bool SearchWaferDestination(SlotItem outSlot, out SlotItem destSlot)
        {
            destSlot = new SlotItem(ModuleName.System, -1);
            var wafer = GetCloneWafer(outSlot.Module, outSlot.Slot);
            if (wafer.IsEmpty || wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null || wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
                return false;

            foreach (var next_module in wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules)
            {
                var validSlots = GetModuleValidSlots(next_module);
                foreach (var nSlot in validSlots)
                {
                    if (_movingItems.Exists(mItem => mItem.DestinationModule == next_module && mItem.DestinationSlot == nSlot))
                        continue;

                    var ready_in = _vacReadyInSlots.Find(item => item.Module == next_module && item.Slot == nSlot);
                    if (ready_in != null && _vacModules[ready_in.Module].MovingStatus != MovingStatus.Moving)
                    {
                        destSlot.Module = ready_in.Module;
                        destSlot.Slot = nSlot;
                        return true;
                    }
                }
            }

            return false;
        }

        List<int> GetModuleValidSlots(ModuleName mod)
        {
            var validSlot = new List<int>();
            if(ModuleHelper.IsLoadLock(mod))
            {
                if(!IsLoadLockReservedByEFEM(mod))
                {
                    var inSlots = mod == ModuleName.LLA ? _LLAInSlot : _LLBInSlot;
                    foreach (var slot in inSlots)
                    {
                        if (WaferManager.Instance.CheckNoWafer(mod, slot) && !_movingItems.Exists(item => item.DestinationModule == mod && item.DestinationSlot == slot))
                            validSlot.Add(slot);

                        if (WaferManager.Instance.CheckHasWafer(mod, slot) && _movingItems.Exists(item => item.SourceModule == mod && item.SourceSlot == slot))
                            validSlot.Add(slot);
                    }
                }

            }
            else if(ModuleHelper.IsPm(mod))
            {
                if (WaferManager.Instance.CheckNoWafer(mod, 0) && !_movingItems.Exists(item => item.DestinationModule == mod))
                    validSlot.Add(0);

                if (WaferManager.Instance.CheckHasWafer(mod, 0) && _movingItems.Exists(item => item.SourceModule == mod))
                    validSlot.Add(0);
            }
            

            return validSlot.Distinct().ToList();
        }

        private int GetModuleSlotCount(ModuleName mod)
        {
            int nSlotCount = 1;
            if(ModuleHelper.IsLoadLock(mod))
            {
                nSlotCount = mod == ModuleName.LLA ? _LLASlotNumber : _LLBSlotNumber;
            }
            else if(ModuleHelper.IsLoadPort(mod))
            {
                nSlotCount = SC.GetValue<int>("EFEM.LoadPort.SlotNumber");
            }
            else if(ModuleHelper.IsTMRobot(mod) || ModuleHelper.IsEFEMRobot(mod))
            {
                nSlotCount = 2;
            }

            return nSlotCount;
        }

        List<MoveItem> SearchWaitInSlots(ModuleName inModule)
        {
            List<MoveItem> inSlots = new List<MoveItem>();
            var validSlots = GetModuleValidSlots(inModule);
            foreach(var slot in _vacReadyOutSlots)
            {
                if (slot.Module == inModule && _vacModules[slot.Module].MovingStatus == MovingStatus.Moving)
                    continue;

                if (IsLoadLockReservedByEFEM(slot.Module))
                    continue;

                var wafer = GetCloneWafer(slot.Module, slot.Slot);

                if (wafer.IsEmpty || wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null || wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
                    continue;

                foreach (var next_module in wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules)
                {
                    if(next_module == inModule && validSlots.Count > 0 && !_movingItems.Exists(item => item.SourceModule == slot.Module && item.SourceSlot == slot.Slot))
                    {
                        if(!inSlots.Exists(item => item.SourceModule == slot.Module && item.SourceSlot == slot.Slot))
                        {
                            inSlots.Add(new MoveItem(slot.Module, slot.Slot, inModule, validSlots.First(), Hand.None));
                        }
                        
                        validSlots.RemoveAt(0);
                    }
                }
            }

            return inSlots;
        }

        private void UpdateItemMovingStatus(MoveItem moveItem, MovingStatus status = MovingStatus.Moving)
        {
            if(!ModuleHelper.IsTMRobot(moveItem.DestinationModule))
            {
                _vacModules[moveItem.DestinationModule].MovingStatus = status;
            }

            if(!ModuleHelper.IsTMRobot(moveItem.SourceModule))
            {
                _vacModules[moveItem.SourceModule].MovingStatus = status;
            }
        }

        private void UpdateModuleMovingStatus(ModuleName module, MovingStatus status = MovingStatus.Moving)
        {
            if (!ModuleHelper.IsTMRobot(module))
            {
                _vacModules[module].MovingStatus = status;
            }
        }

        private void ProcessTMRobotTask()
        {
            if(_tmRobot.IsAvailable)
            {
                if(WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) || WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 1))
                {
                    return;
                }

                foreach(var slot in _vacReadyOutSlots)
                {
                    if (_vacModules[slot.Module].MovingStatus != MovingStatus.Idle)
                        continue;

                    if (ModuleHelper.IsLoadLock(slot.Module))
                    {
                        if (IsLoadLockReservedByEFEM(slot.Module))
                            continue;

                        if(SearchWaferDestination(slot, out SlotItem destSlot))
                        {
                            _movingItems.Add(new MoveItem(slot.Module, slot.Slot, destSlot.Module, destSlot.Slot, Hand.None));
                            UpdateModuleMovingStatus(slot.Module);
                            UpdateModuleMovingStatus(destSlot.Module);

                            // check whether match double pick pattern
                            var out_slot_2 = _vacReadyOutSlots.Find(item => item.Module == slot.Module && item.Slot != slot.Slot);
                            if (out_slot_2 != null)
                            {
                                if(SearchWaferDestination(out_slot_2, out SlotItem destSlot_2))
                                {
                                    _movingItems.Add(new MoveItem(out_slot_2.Module, out_slot_2.Slot, destSlot_2.Module, destSlot_2.Slot, Hand.None));
                                    UpdateModuleMovingStatus(out_slot_2.Module);
                                    UpdateModuleMovingStatus(destSlot_2.Module);
                                }
                            }

                            // check whether match swap pattern
                            var in_slots = SearchWaitInSlots(slot.Module);
                            foreach(var in_slot in in_slots)
                            {
                                if(_vacModules[in_slot.Module].MovingStatus == MovingStatus.Idle)
                                {
                                    _movingItems.Add(in_slot);
                                    UpdateItemMovingStatus(in_slot);
                                }
                            }

                            return;
                        }
                    }
                    else // PM
                    {
                        if(SearchWaferDestination(slot, out SlotItem destSlot))
                        {
                            _movingItems.Add(new MoveItem(slot.Module, slot.Slot, destSlot.Module, destSlot.Slot, Hand.None));
                            UpdateModuleMovingStatus(slot.Module);
                            UpdateModuleMovingStatus(destSlot.Module);

                            // check whether match swap pattern
                            var in_slots = SearchWaitInSlots(slot.Module);
                            if(in_slots.Count >= 1)
                            {
                                _movingItems.Add(in_slots.First());
                                UpdateItemMovingStatus(in_slots.First());
                            }
                            else
                            {
                                // check whether match double move pattern
                                var same_dest = SearchWaitInSlots(destSlot.Module);
                                if(same_dest.Count > 0 && _vacModules[same_dest[0].SourceModule].MovingStatus == MovingStatus.Idle)
                                {
                                    _movingItems.Add(same_dest[0]);
                                    UpdateItemMovingStatus(same_dest[0]);
                                }
                            }

                            return;
                        }
                    }
                }

                _vacReadyOutSlots.Clear();
                _vacReadyInSlots.Clear();
            }
        }

        private void RuningTMRobotTask()
        {
            if(_tmRobot.IsAvailable)
            {
                if(_tmRobot.PostMoveItems(_movingItems.ToArray()))
                {
                    
                    foreach(var item in _movingItems)
                    {
                        var wafer = WaferManager.Instance.GetWafer(item.SourceModule, item.SourceSlot);
                        if (wafer.IsEmpty)
                        {
                            // post alarm
                            _cycleState = RState.Failed;
                            LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"Cannot run TM moving task as Get {item.SourceModule}{item.SourceModule} Wafer Info failed");
                            return;
                        }

                        var slot = new SlotItem(item.DestinationModule, item.DestinationSlot);
                        _vacWaferTargets[slot] = wafer.InnerId;
                    }
                }
            }
        }

        private void ProcessPMTask()
        {
            foreach(var mod in _vacModules)
            {
                if(ModuleHelper.IsPm(mod.Key))
                {
                    if(_vacSchedulers[mod.Key].IsAvailable)
                    {
                        switch (mod.Value.MovingStatus)
                        {
                            case MovingStatus.WaitProcess:
                                {
                                    _vacSchedulers[mod.Key].EventWaferArrived?.Invoke(this,  new WaferMoveArgs(ModuleName.TMRobot, 0, mod.Key, 0));
                                    mod.Value.MovingStatus = MovingStatus.StartProcess;
                                }
                                break;
                            case MovingStatus.Processing:
                                mod.Value.MovingStatus = MovingStatus.Idle;
                                break;
                        }
                    }
                    else
                    {
                        switch(mod.Value.MovingStatus)
                        {
                            case MovingStatus.StartProcess:
                                mod.Value.MovingStatus = MovingStatus.Processing;
                                break;
                        }
                    }

                }
            }
        }

        private Hand GetTMRobotFreeHand()
        {
            var blade1HasWafer = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0);
            var blade2HasWafer = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 1);
            if (blade1HasWafer && blade2HasWafer)
                return Hand.None;
            else if (!blade1HasWafer && !blade2HasWafer)
                return Hand.Both;
            else if (blade1HasWafer)
                return Hand.Blade2;
            else
                return Hand.Blade1;
        }

        private bool IsVacWaferReadyOut(ModuleName mod, int slot)
        {
            var wafer = GetCloneWafer(mod, slot);

            if (wafer.IsEmpty)
                return false;

            if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
                return false;

            if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
            {
                // should not go here
                //LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"Wafer:{wafer.WaferOrigin} NextSequenceStep {wafer.NextSequenceStep} exceeds {wafer.ProcessJob.Sequence.Name} max steps number");
                return false;
            }

            if (wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(mod))
                return false;

            foreach(var module in wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules)
            {
                if (ModuleHelper.IsLoadLock(module) || ModuleHelper.IsPm(module))
                    return true;
            }

            return false;
        }

        #endregion Vacuum System

        #region Atm System
        private void driveAtmSystem()
        {
            PumpingEFEMRobotTask();
            RuningEFEMRobotTask();
        }

        private void PumpingEFEMRobotTask()
        {
            if (!_efemRobot.IsAvailable)
                return;

            foreach(var scheduler in _atmSchedulers)
            {
                if (!scheduler.Value.IsAvailable)
                    continue;

                if(ModuleHelper.IsLoadLock(scheduler.Key))
                {
                    if (ProcessLLEFEMRobotTask(scheduler.Key))
                        return;
                }
                else if(ModuleHelper.IsAligner(scheduler.Key))
                {
                    if (ProcessAlignerEFEMRobotTask(scheduler.Key))
                        return;
                }
                else if(ModuleHelper.IsCooling(scheduler.Key))
                {
                    if (ProcessCoolingEFEMRobotTask(scheduler.Key))
                        return;
                }
                else if (ModuleHelper.IsLoadPort(scheduler.Key))
                {
                    if (ProcessLPEFEMRobotTask(scheduler.Key))
                        return;
                }
                else
                {
                    // should not go here
                    LOG.Write(eEvent.ERR_ROUTER, $"Wrong Module: {scheduler.Key} in ATM System");
                }
            }
        }

        List<int> GetEfemRobotWaferReadyInHands(ModuleName mod)
        {
            var slots = new List<int>();
            for(int i = 0; i < 2; i++)
            {
                var wafer = GetCloneWafer(ModuleName.EfemRobot, i);
                if (wafer.IsEmpty)
                    continue;

                if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
                    continue;

                if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
                {
                    // should not go here
                    LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"Wafer:{wafer.WaferOrigin} NextSequenceStep {wafer.NextSequenceStep} exceeds {wafer.ProcessJob.Sequence.Name} max steps number");
                    continue;
                }

                if (wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(mod))
                {
                    slots.Add(i);
                }
            }

            return slots;
        }

        bool IsAtmWaferReadyOut(ModuleName mod, int slot)
        {
            var wafer = GetCloneWafer(mod, slot);

            if (wafer.IsEmpty)
                return false;

            if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
                return false;

            if (wafer.NextSequenceStep == wafer.ProcessJob.Sequence.Steps.Count)
            {
                // need return
                return true; 
            }
            else if(wafer.NextSequenceStep > wafer.ProcessJob.Sequence.Steps.Count)
            {
                // should not go here
                LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"Wafer:{wafer.WaferOrigin} NextSequenceStep {wafer.NextSequenceStep} exceeds {wafer.ProcessJob.Sequence.Name} max steps number");
                return false;
            }

            if (wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(mod))
                return false;

            if(ModuleHelper.IsLoadLock(mod))
            {
                foreach (var module in wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules)
                {
                    if (ModuleHelper.IsPm(module))
                        return false;
                }
            }

            return true;
        }
        private bool ProcessLLEFEMRobotTask(ModuleName ll)
        {
            if (_vacModules[ll].MovingStatus != MovingStatus.Idle ||  IsLoadLockReservedByTM(ll))
                return false;

            var robotSlots = GetEfemRobotWaferReadyInHands(ll);
            var inSlots = ll == ModuleName.LLA ? _LLAInSlot : _LLBInSlot;
            foreach(var slot in inSlots)
            {
                if(robotSlots.Count >= 1)
                {
                    if(WaferManager.Instance.CheckNoWafer(ll, slot))
                    {
                        _efemMovingItems.Add(new MoveItem(ModuleName.EfemRobot, robotSlots.First(), ll, slot, (Hand)robotSlots.First()));
                        robotSlots.RemoveAt(0);
                    }
                }
            }

            var outSlots = ll == ModuleName.LLA ? _LLAOutSlot : _LLBOutSlot;

            foreach(var slot in outSlots)
            {
                if(IsAtmWaferReadyOut(ll, slot))
                {
                    var robotHand = GetEFEMRobotFreeHand();
                    if(robotHand !=  Hand.None)
                    {
                        _efemMovingItems.Add(new MoveItem(ll, slot, ModuleName.EfemRobot, (int)robotHand, robotHand));
                    }
                }
            }

            return _efemMovingItems.Count > 0;
        }

        private Tuple<int, int> GetPMWaferExistence()
        {
            int exist = 0;
            int empty = 0;
            foreach (var module in _vacModules)
            {
                if (ModuleHelper.IsPm(module.Key))
                {
                    if (WaferManager.Instance.CheckHasWafer(module.Key, 0))
                        exist++;
                    else
                        empty++;
                }
                    
            }

            return new Tuple<int, int>(exist, empty);
        }

        private int GetTMRobotWaferCount()
        {
            return (WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) ? 1 : 0) + (WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 1) ? 1 : 0);
        }

        private int GetEfemRoborWaferCount()
        {
            return (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, 0) ? 1 : 0) + (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, 1) ? 1 : 0);
        }

        private bool IsLoadLockReservedByEFEM(ModuleName ll)
        {
            if (_efemMovingItems.Exists(item => item.DestinationModule == ll || item.SourceModule == ll))
                return true;

            return false;
        }

        private bool IsLoadLockReservedByTM(ModuleName ll)
        {
            if (_movingItems.Exists(item => item.DestinationModule == ll || item.SourceModule == ll))
                return true;

            return false;
        }

        private Tuple<int, int>  GetLLProcessStatusCount(ModuleName ll)
        {
            int processedCount = 0;
            int unprocessCount = 0;
            int slotCount = ll == ModuleName.LLA ? _LLASlotNumber : _LLBSlotNumber;
            if(ModuleHelper.IsLoadLock(ll))
            {
                for(int i = 0; i < slotCount;i++)
                {
                    if(WaferManager.Instance.CheckHasWafer(ll, i))
                    {
                        if(CheckWaferNeedProcessAndPMAvailable(ll, i))
                            unprocessCount++;
                        else
                            processedCount++;
                    }
                }
            }

            return new Tuple<int, int>(processedCount, unprocessCount);
        }


        private int GetAtmInerWaferCount()
        {
            int nCount = 0;
            foreach(var atmModule in _atmModules)
            {
                if (!ModuleHelper.IsEFEMRobot(atmModule.Key) && WaferManager.Instance.CheckHasWafer(atmModule.Key, 0))
                    nCount++;
            }

            return nCount;
        }
        private bool IsReadyPushWaferIn()
        {
            var llaWaferStatus = GetLLProcessStatusCount(ModuleName.LLA);
            var llbWaferStatus = GetLLProcessStatusCount(ModuleName.LLB);
            var pmWaferStatus = GetPMWaferExistence();

            if (llaWaferStatus.Item1 + llbWaferStatus.Item1 > 0)
                return false;

            if (_LLAInSlot.Count + _LLBInSlot.Count + pmWaferStatus.Item2 - llaWaferStatus.Item2 - llbWaferStatus.Item2 <= 2)
                return false;

            if (GetEfemRoborWaferCount() >= 1 && GetAtmInerWaferCount() > 0)
                return false;

            return true;
        }

        private bool IsForwardPathBlocking(ModuleName mod, int slot)
        {
            var wafer = GetCloneWafer(mod, slot);
            if (wafer.IsEmpty || wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null || wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
                return false;

            foreach (var next_module in wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules)
            {
                var SlotNumber = GetModuleSlotCount(next_module);
                for(int i = 0; i < SlotNumber; i++)
                {
                    if (WaferManager.Instance.CheckNoWafer(next_module, i))
                        return false;
                }
            }

            return true;
        }

        private bool ProcessLPEFEMRobotTask(ModuleName lp)
        {
            // check return
            for(int i = 0; i < 2; i++)
            {
                if(WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, i))
                {
                    var returnWafer = WaferManager.Instance.GetWafer(ModuleName.EfemRobot, i);
                    if (returnWafer.IsEmpty)
                        continue;

                    if (returnWafer.ProcessJob == null || returnWafer.ProcessJob.Sequence == null)
                        continue;

                    if (returnWafer.NextSequenceStep >= returnWafer.ProcessJob.Sequence.Steps.Count && lp == (ModuleName)returnWafer.OriginStation)  // need return
                    {
                        _efemMovingItems.Add(new MoveItem(ModuleName.EfemRobot, i, lp, returnWafer.OriginSlot, (Hand)i));
                    }
                }
            }

            if(_efemMovingItems.Count == 0 && IsReadyPushWaferIn())
            {
                var outSlots = GetNextWaferInJobQueue(lp);

                var hand = GetEFEMRobotFreeHand();
                if (hand != Hand.None && outSlots.Count > 0)
                {
                    _efemMovingItems.Add(new MoveItem(lp, outSlots[0], ModuleName.EfemRobot, (int)hand, hand));
                }


                hand = GetEFEMRobotFreeHand();
                if (hand != Hand.None && outSlots.Count> 1 && !IsForwardPathBlocking(lp, outSlots[1]))
                {
                    _efemMovingItems.Add(new MoveItem(lp, outSlots[1], ModuleName.EfemRobot, (int)hand, hand));
                }

            }

            return _efemMovingItems.Count > 0;
        }

        private List<int> GetNextWaferInJobQueue(ModuleName lp)
        {
            var inSlots = new List<int>();

            foreach (var cj in _lstControlJobs)
            {
                if (lp != ModuleName.System && (cj.Module != lp.ToString()))
                    continue;

                if (cj.State == EnumControlJobState.Executing)
                {
                    foreach (var pj in _lstProcessJobs)
                    {
                        if (pj.ControlJobName == cj.Name && pj.State == EnumProcessJobState.Processing)
                        {
                            foreach (var pjSlotWafer in pj.SlotWafers)
                            {
                                if (CheckWaferNeedProcessAndPMAvailable(pjSlotWafer.Item1, pjSlotWafer.Item2))
                                {
                                    //return new SlotItem(pjSlotWafer.Item1, pjSlotWafer.Item2);
                                    inSlots.Add(pjSlotWafer.Item2);
                                }

                            }
                        }
                    }
                }
            }

            return inSlots;
        }

        private bool ProcessAlignerEFEMRobotTask(ModuleName aligner)
        {
            if(WaferManager.Instance.CheckHasWafer(aligner, 0) && IsAtmWaferReadyOut(aligner, 0))
            {
                var hand = GetEFEMRobotFreeHand();
                if(hand != Hand.None)
                {
                    _efemMovingItems.Add(new MoveItem(aligner, 0, ModuleName.EfemRobot, (int)hand, hand));
                }

                //// check with whether another robot arm wafer wait go to aligner
                //var robotSlots = GetEfemRobotWaferReadyInHands(aligner);
                //if (robotSlots.Count > 0)
                //{
                //    _efemMovingItems.Add(new MoveItem(ModuleName.EfemRobot, robotSlots.First(), aligner, 0, (Hand)robotSlots.First()));
                //}
            }
            else if(WaferManager.Instance.CheckNoWafer(aligner, 0))
            {
                var robotSlots = GetEfemRobotWaferReadyInHands(aligner);
                if(robotSlots.Count > 0)
                {
                    _efemMovingItems.Add(new MoveItem(ModuleName.EfemRobot, robotSlots.First(), aligner, 0, (Hand)robotSlots.First()));
                }
            }

            return _efemMovingItems.Count > 0;
        }

        private bool ProcessCoolingEFEMRobotTask(ModuleName cooling)
        {
            if (WaferManager.Instance.CheckHasWafer(cooling, 0) && IsAtmWaferReadyOut(cooling, 0))
            {
                var hand = GetEFEMRobotFreeHand();
                if (hand != Hand.None)
                {
                    _efemMovingItems.Add(new MoveItem(cooling, 0, ModuleName.EfemRobot, (int)hand, hand));
                }
            }
            else
            {
                var robotSlots = GetEfemRobotWaferReadyInHands(cooling);
                if (robotSlots.Count > 0)
                {
                    _efemMovingItems.Add(new MoveItem(cooling, 0, ModuleName.EfemRobot, robotSlots.First(), (Hand)robotSlots.First()));
                }
            }

            return _efemMovingItems.Count > 0;
        }

        private void RuningEFEMRobotTask()
        {
            if (_efemRobot.IsAvailable && _efemMovingItems.Count > 0)
            {
                if (_efemRobot.PostMoveItems(_efemMovingItems.ToArray()))
                {

                    foreach (var item in _efemMovingItems)
                    {
                        var wafer = WaferManager.Instance.GetWafer(item.SourceModule, item.SourceSlot);
                        if (wafer.IsEmpty)
                        {
                            // post alarm
                            _cycleState = RState.Failed;
                            LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"Cannot run EFEM moving task as Get {item.SourceModule}{item.SourceModule} Wafer Info failed");
                            return;
                        }

                        var slot = new SlotItem(item.DestinationModule, item.DestinationSlot);
                        _atmWaferTargets[slot] = wafer.InnerId;

                        if(ModuleHelper.IsLoadLock(item.Module))
                        {
                            _vacModules[item.Module].MovingStatus = MovingStatus.Moving;
                        }
                    }
                }
            }
        }

        private Hand GetEFEMRobotFreeHand()
        {
            for(int i = 0; i < 2; i++)
            {
                if ((WaferManager.Instance.CheckNoWafer(ModuleName.EfemRobot, i) && 
                    !_efemMovingItems.Exists(item => item.DestinationModule == ModuleName.EfemRobot && item.DestinationSlot == i)) ||
                (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, i) && 
                _efemMovingItems.Exists(item => item.SourceModule == ModuleName.EfemRobot && item.SourceSlot == i) && 
                !_efemMovingItems.Exists(item => item.DestinationModule == ModuleName.EfemRobot && item.DestinationSlot == i)))
                return (Hand)i;
            }

            return Hand.None;
        }

        #endregion Atm System

        #region Sequence validation
        private bool CheckSequencePmReady(SequenceInfo seq, List<ModuleName> pmOccupied, out List<ModuleName> pmUsed, out string reason)
        {
            pmUsed = new List<ModuleName>();
            reason = "";
            bool pmIsReady = true;

            for (int i = 0; i < seq.Steps.Count; i++)
            {
                SequenceStepInfo stepInfo = seq.Steps[i];
                bool hasPm = false;
                foreach (var module in stepInfo.StepModules)
                {
                    if (!ModuleHelper.IsPm(module))
                    {
                        hasPm = true;
                        break;
                    }

                    if (ModuleHelper.IsInstalled(module) && (pmOccupied == null || !pmOccupied.Contains(module)))
                    {
                        hasPm = true;
                    }

                    if (!pmUsed.Contains(module))
                        pmUsed.Add(module);
                }

                if (pmIsReady && !hasPm)
                {
                    reason = $"Step {i + 1} no valid PM, " + string.Join("|", stepInfo.StepModules);
                    pmIsReady = false;
                }
            }

            return pmIsReady;
        }

        private bool CheckSequenceRecipeFileValid(SequenceInfo seq, out string reason)
        {
            for (int i = 0; i < seq.Steps.Count; i++)
            {
                SequenceStepInfo stepInfo = seq.Steps[i];
                foreach (var module in stepInfo.StepModules)
                {
                    if (ModuleHelper.IsPm(module))
                    {
                        string attr = $"{module}Recipe";
                        if (stepInfo.StepParameter.ContainsKey(attr)
                            && !string.IsNullOrEmpty((string)stepInfo.StepParameter[attr]))
                        {
                            var recipeName = (string)stepInfo.StepParameter[attr];
                            if (!string.IsNullOrEmpty(recipeName))
                            {
                                var recipeContent =
                                    RecipeFileManager.Instance.LoadRecipe($"{module}", recipeName, false);
                                if (string.IsNullOrEmpty(recipeContent))
                                {
                                    reason = $"Can not find recipe file{recipeName}";
                                    return false;
                                }
                            }
                        }
                    }
                }
            }

            reason = "";
            return true;
        }

        private bool CheckWaferNeedProcessAndPMAvailable(ModuleName waferModule, int waferSlot, ModuleName processIn = ModuleName.System)
        {
            WaferInfo wafer = GetCloneWafer(waferModule, waferSlot);

            if (wafer.IsEmpty)
                return false;

            if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
                return false;

            if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
                return false;

            for (int i = wafer.NextSequenceStep; i < wafer.ProcessJob.Sequence.Steps.Count; i++)
            {
                var hasPmAvailable = false;
                foreach (var stepModule in wafer.ProcessJob.Sequence.Steps[i].StepModules)
                {
                    if (!ModuleHelper.IsPm(stepModule))
                        break;

                    if (!_vacSchedulers.Keys.Contains(stepModule))
                        continue;

                    var pm = _vacSchedulers[stepModule] as SchedulerPM;
                    if (pm != null)
                    {
                        if (pm.IsAvailable || (pm.IsOnline && pm.Task != SchedulerModule.TaskType.PreJobProcess))
                        {
                            hasPmAvailable = true;
                            break;
                        }
                    }
                }

                if (!hasPmAvailable)
                    continue;

                if (processIn == ModuleName.System)
                    return true;

                if (wafer.ProcessJob.Sequence.Steps[i].StepModules
                    .Contains(processIn))
                    return true;
            }

            return false;
        }

        private List<ModuleName> GetPmUsedInRunningPj()
        {
            var pmUsed = new List<ModuleName>();
            foreach (var cj in _lstControlJobs)
            {
                if (cj.State != EnumControlJobState.Executing && cj.State != EnumControlJobState.Paused)
                    continue;

                foreach (var pj in _lstProcessJobs)
                {
                    if (pj.ControlJobName == cj.Name && (pj.State == EnumProcessJobState.Processing || pj.State == EnumProcessJobState.Paused))
                    {
                        for (int i = 0; i < pj.Sequence.Steps.Count; i++)
                        {
                            SequenceStepInfo stepInfo = pj.Sequence.Steps[i];
                            foreach (var module in stepInfo.StepModules)
                            {
                                if (ModuleHelper.IsPm(module) && !pmUsed.Contains(module))
                                    pmUsed.Add(module);
                            }
                        }
                    }
                }
            }

            return pmUsed;
        }

        private List<SchedulerPM> GetPmNeeded(ControlJobInfo cj)
        {
            List<SchedulerPM> result = new List<SchedulerPM>();

            foreach (var pj in _lstProcessJobs)
            {
                if (pj.ControlJobName != cj.Name)
                    continue;

                var seq = pj.Sequence;
                for (int i = 0; i < seq.Steps.Count; i++)
                {
                    SequenceStepInfo stepInfo = seq.Steps[i];
                    foreach (var module in stepInfo.StepModules)
                    {
                        if (ModuleHelper.IsPm(module) && _vacSchedulers.ContainsKey(module))
                        {
                            var pm = _vacSchedulers[module] as SchedulerPM;

                            if (pm != null && !result.Contains(pm))
                            {
                                result.Add(pm);
                            }
                        }
                    }
                }
            }


            return result;
        }

        private void UpateSequenceStep(List<MoveItem> items)
        {
            foreach(var item in items)
            {
                if(!ModuleHelper.IsTMRobot(item.DestinationModule) && !ModuleHelper.IsEFEMRobot(item.DestinationModule))
                {
                    var wafer = WaferManager.Instance.GetWafer(item.DestinationModule, item.DestinationSlot);
                    if(!wafer.IsEmpty && wafer.ProcessJob != null)
                    {
                        if (wafer.NextSequenceStep < wafer.ProcessJob.Sequence.Steps.Count && wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(item.DestinationModule))
                            wafer.NextSequenceStep++;
                    }
                    
                    if(wafer.IsEmpty || wafer.ProcessJob == null)
                    {
                        // should not go here
                        LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"UpateSequenceStep() failed, location: {item.DestinationModule}:{item.DestinationSlot}, NextSequenceStep: {wafer.NextSequenceStep}");
                    }
                }
            }
        }
        private void CheckWaferArrived()
        {
            if (_cycleState != RState.Running)
                return;

            foreach (var mod in _vacSchedulers.Append(new KeyValuePair<ModuleName, SchedulerModule>( ModuleName.TMRobot, _tmRobot)))
            {
                //if (mod.Value.IsAvailable)
                {
                    var tars = _vacWaferTargets.Where(item => item.Key.Module == mod.Key).ToArray();
                    foreach (var tar in tars)
                    {
                        var wafer = WaferManager.Instance.GetWafer(tar.Key.Module, tar.Key.Slot);
                        if (wafer.IsEmpty)
                            continue;

                        if (wafer.InnerId == tar.Value)
                        {
                            // wafer arrive
                            _vacWaferTargets.Remove(tar.Key);

                            if (ModuleHelper.IsPm(tar.Key.Module))
                            {
                                _vacModules[tar.Key.Module].MovingStatus = MovingStatus.WaitProcess;
                            }
                        }
                    }
                }
            }

            _vacMoveFinishTrig.CLK = _vacWaferTargets.Count == 0;
            if (_vacMoveFinishTrig.Q)
            {
                foreach(var item in _movingItems)
                {
                    if(_vacModules[item.DestinationModule].MovingStatus == MovingStatus.Moving)
                    {
                        _vacModules[item.DestinationModule].MovingStatus = MovingStatus.Idle;
                    }

                    if(_vacModules[item.SourceModule].MovingStatus == MovingStatus.Moving)
                    {
                        _vacModules[item.SourceModule].MovingStatus = MovingStatus.Idle;
                    }
                }

                UpateSequenceStep(_movingItems);
                _movingItems.Clear();
            }

            foreach (var mod in _atmSchedulers.Append(new KeyValuePair<ModuleName, SchedulerModule>(ModuleName.EfemRobot, _efemRobot)))
            {
                //if (mod.Value.IsAvailable)
                {
                    var tars = _atmWaferTargets.Where(item => item.Key.Module == mod.Key).ToArray();
                    foreach (var tar in tars)
                    {
                        var wafer = WaferManager.Instance.GetWafer(tar.Key.Module, tar.Key.Slot);
                        if (wafer.IsEmpty)
                            continue;

                        if (wafer.InnerId == tar.Value)
                        {
                            // wafer arrive
                            _atmWaferTargets.Remove(tar.Key);
                        }
                    }
                }
            }

            _atmMoveFinishTrig.CLK = _atmWaferTargets.Count == 0;
            if(_atmMoveFinishTrig.Q)
            {
                foreach(var item in _efemMovingItems)
                {
                    if(ModuleHelper.IsLoadLock(item.Module))
                    {
                        _vacModules[item.Module].MovingStatus = MovingStatus.Idle;
                    }
                }

                UpateSequenceStep(_efemMovingItems);
                _efemMovingItems.Clear();
            }
        }
        private void PreJobClean(ControlJobInfo cj)
        {
            if (cj.IsPreJobCleanDone)
                return;

            cj.IsPreJobCleanDone = true;

            List<SchedulerPM> pms = GetPmNeeded(cj);
            foreach (var pm in pms)
            {
                pm.PreJobClean();
            }
        }
        private bool ActiveProcessJob(ProcessJobInfo pj)
        {
            foreach (var pjSlotWafer in pj.SlotWafers)
            {
                WaferInfo wafer = WaferManager.Instance.GetWafer(pjSlotWafer.Item1, pjSlotWafer.Item2);

                wafer.ProcessJob = pj;
                wafer.NextSequenceStep = 0;

                WaferDataRecorder.SetPjInfo(wafer.InnerId.ToString(), pj.InnerId.ToString());
            }

            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == pj.ControlJobName);

            CarrierInfo carrier = CarrierManager.Instance.GetCarrier(cj.Module);
            JobDataRecorder.StartPJ(pj.InnerId.ToString(), carrier.InnerId.ToString(), cj.InnerId.ToString(), pj.Name, cj.Module, cj.Module, pj.SlotWafers.Count);

            pj.SetState(EnumProcessJobState.Processing);

            PreJobClean(cj);

            return true;
        }
        private void StartNewJob()
        {
            ControlJobInfo cjActived = null;

            List<ModuleName> pmOccupied = GetPmUsedInRunningPj();
            foreach (var cj in _lstControlJobs)
            {
                if (cj.State != EnumControlJobState.Executing)
                    continue;

                cjActived = cj;

                foreach (var pjName in cjActived.ProcessJobNameList)
                {
                    var pj = _lstProcessJobs.Find(x => x.Name == pjName);
                    if (pj == null)
                    {
                        LOG.Write(eEvent.ERR_ROUTER, ModuleName.System, $"Not find pj named {pjName} in {cjActived.Name}");
                        continue;
                    }

                    if (pj.State == EnumProcessJobState.Queued)
                    {
                        if (CheckSequencePmReady(pj.Sequence, pmOccupied, out var pmUsed, out string reason))
                        {
                            ActiveProcessJob(pj);

                            foreach (var moduleName in pmUsed)
                            {
                                if (!pmOccupied.Contains(moduleName))
                                    pmOccupied.Add(moduleName);
                            }
                        }
                        break;
                    }
                }
            }
        }


        private static bool IsWaferNeedGotoModule(WaferInfo wafer, ModuleName module)
        {
            if (wafer.IsEmpty)
                return false;

            if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
                return false;

            if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
                return false;

            for (int i = wafer.NextSequenceStep; i < wafer.ProcessJob.Sequence.Steps.Count; i++)
            {
                if (wafer.ProcessJob.Sequence.Steps[i].StepModules
                        .Contains(module))
                    return true;
            }

            return false;
        }
        private bool CheckAllWaferReturned(ProcessJobInfo pj, bool checkAllProcessed)
        {
            for (int i = 0; i < pj.SlotWafers.Count; ++i)
            {
                WaferInfo wafer = GetCloneWafer(pj.SlotWafers[i].Item1, pj.SlotWafers[i].Item2);
                if (wafer.IsEmpty)
                    return false;

                if (checkAllProcessed && IsWaferNeedGotoModule(wafer, ModuleName.PMA) || IsWaferNeedGotoModule(wafer, ModuleName.PMB))
                    return false;
            }

            return true;
        }

        private void UpdateProcessJobStatus()
        {
            foreach (var pj in _lstProcessJobs)
            {
                if (pj.State == EnumProcessJobState.Processing)
                {
                    if (CheckAllWaferReturned(pj, true))
                    {
                        pj.SetState(EnumProcessJobState.ProcessingComplete);
                        JobDataRecorder.EndPJ(pj.InnerId.ToString(), 0, 0);
                    }
                }
                else if (pj.State == EnumProcessJobState.Stopping)
                {
                    if (CheckAllWaferReturned(pj, false))
                    {
                        pj.SetState(EnumProcessJobState.ProcessingComplete);
                        JobDataRecorder.EndPJ(pj.InnerId.ToString(), 0, 0);
                    }
                }

            }
        }

        private void CompleteJobClean(ControlJobInfo cj)
        {
            List<SchedulerPM> pms = GetPmNeeded(cj);
            foreach (var pm in pms)
            {
                pm.CompleteJobClean();
            }
        }
        private void UpdateControlJobStatus()
        {
            if (_lstControlJobs.Count == 0)
                return;

            //if (_curAction.state != ActionState.Done)
            //    return;

            bool allControlJobComplete = true;
            List<ControlJobInfo> cjRemoveList = new List<ControlJobInfo>();
            foreach (var cj in _lstControlJobs)
            {
                if (!Singleton<TransferModule>.Instance.GetScheduler(ModuleHelper.Converter(cj.Module)).IsAvailable)
                {
                    allControlJobComplete = false;
                    continue;
                }
                if (cj.State == EnumControlJobState.Executing)
                {
                    bool allPjCompleted = true;
                    foreach (var pjName in cj.ProcessJobNameList)
                    {
                        var pj = _lstProcessJobs.Find(x => x.Name == pjName);
                        if (pj == null)
                        {
                            LOG.Write( eEvent.ERR_ROUTER, ModuleName.System, $"Not find pj named {pjName} in {cj.Name}");
                            continue;
                        }
                        if (pj.State != EnumProcessJobState.Complete && pj.State != EnumProcessJobState.ProcessingComplete)
                        {
                            allPjCompleted = false;
                            break;
                        }

                        if (allPjCompleted)
                        {
                            pj.SlotWafers.ForEach(p => {
                                if (ModuleHelper.IsLoadPort(p.Item1))
                                {
                                    allPjCompleted = allPjCompleted && WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(p.Item1.ToString()), p.Item2);
                                }
                            });
                        }
                    }

                    if (allPjCompleted)
                    {
                        cj.SetState(EnumControlJobState.Completed);
                        cj.EndTime = DateTime.Now;

                        if (!(_isCycleMode && _cycledCount + 1 < _cycleSetPoint))
                        {
                            CompleteJobClean(cj);
                        }

                        _faCallback.JobFinished(cj, GetFirstProcessJob(cj));
                        _dbCallback.LotFinished(cj);

                        if (!(_isCycleMode && _cycledCount < _cycleSetPoint))
                            (Singleton<TransferModule>.Instance.GetScheduler(ModuleHelper.Converter(cj.Module)) as SchedulerLoadPort).NoteJobComplete();
                    }
                }


                LoadportCassetteState state = (LoadportCassetteState)DATA.Poll($"{cj.Module}.CassetteState");
                if (cj.State == EnumControlJobState.Completed && state != LoadportCassetteState.Normal)
                {
                    cjRemoveList.Add(cj);
                }

                allControlJobComplete = allControlJobComplete && cj.State == EnumControlJobState.Completed;
            }

            if (_isCycleMode && _cycledCount < (_isCycleMode ? _cycleSetPoint : 0))
            {
                int countPerCycle = 0;
                int countProcessed = 0;
                foreach (var pj in _lstProcessJobs)
                {
                    foreach (var pjSlotWafer in pj.SlotWafers)
                    {
                        countPerCycle++;
                        WaferInfo wafer = GetCloneWafer(pjSlotWafer.Item1, pjSlotWafer.Item2);
                        if (!wafer.IsEmpty && !IsWaferNeedGotoModule(wafer, ModuleName.PMA) && !IsWaferNeedGotoModule(wafer, ModuleName.PMB))
                            countProcessed++;
                    }
                }

                _cycledWafer = _cycledCount * countPerCycle + countProcessed;

                if (allControlJobComplete)
                {
                    _cycledCount++;

                    if (_cycledCount < _cycleSetPoint)
                    {
                        foreach (var cj in _lstControlJobs)
                        {
                            cj.SetState(EnumControlJobState.Executing);

                            cj.LotInnerId = Guid.NewGuid();

                            _dbCallback.LotCreated(cj);
                        }
                        foreach (var pj in _lstProcessJobs)
                        {
                            pj.SetState(EnumProcessJobState.Queued);
                            pj.InnerId = Guid.NewGuid();
                            foreach (var pjSlotWafer in pj.SlotWafers)
                            {
                                WaferInfo wafer = WaferManager.Instance.GetWafer(pjSlotWafer.Item1, pjSlotWafer.Item2);

                                wafer.ProcessJob = null;
                                wafer.NextSequenceStep = 0;
                                wafer.ProcessState = EnumWaferProcessStatus.Idle;
                            }
                        }
                    }
                    else
                        _cycleState = RState.End;
                }

            }

            foreach (var cj in cjRemoveList)
            {
                List<ProcessJobInfo> pjRemoveList = new List<ProcessJobInfo>();
                foreach (var pj in _lstProcessJobs)
                {
                    if (pj.ControlJobName == cj.Name)
                        pjRemoveList.Add(pj);
                }

                foreach (var pj in pjRemoveList)
                {
                    _lstProcessJobs.Remove(pj);
                }

                _lstControlJobs.Remove(cj);
            }
        }

        private static WaferInfo GetCloneWafer(ModuleName mod, int slot)
        {
            var Wafer = WaferManager.Instance.GetWafer(mod, slot);
            if (Wafer.IsEmpty || Wafer.ProcessJob == null || Wafer.ProcessJob.Sequence == null)
                return Wafer;

            var cloneWafer = SerializeHelper.DeepCopyJson(Wafer);

            if (Wafer.IsEmpty || Wafer.ProcessJob == null || Wafer.ProcessJob.Sequence == null)
                return Wafer;

            return cloneWafer;
        }

        #endregion
    }
}