using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows.Media.Imaging;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using SicRT.Modules.Schedulers;
using SicRT.Scheduler;

namespace SicRT.Modules
{
    public partial class AutoTransfer : SchedulerModuleFactory
    {
        /* 几个问题待解决
         * 1.参数
         * 2.Routine判断是否执行完了
         * 
         */
        private bool _isPmAInstal = true;
        private bool _isPmBInstal = false;
        private bool _cotrolJobComplete = false;

        private List<ControlJobInfo> _lstControlJobs = new List<ControlJobInfo>();
        private List<ProcessJobInfo> _lstProcessJobs = new List<ProcessJobInfo>();

        //private Object _locker = new Object();
        private List<SchedulerPM> _lstPmsCurrentSequence = new List<SchedulerPM>();

        private const string LogSource = "Scheduler";
        private const string StatsNameTotalRunningWafer = "TotalRunningWafer";
        private const string StatsNameTotalWaferProcessedPM1 = "PM1.WaferProcessed";
        private const string StatsNameTotalWaferProcessedPM2 = "PM2.WaferProcessed";

        private bool _isInited;

        private bool _isCycleMode;
        private int _cycleSetPoint = 0;
        private int _cycledCount = 0;
        private int _cycledWafer = 0;
        private int _totalWaferWhenStart = 0;
        private bool _AllModuleFinised = false;  //所有模块工作都已经完成
        private string _curRecipeName = "";
        private string _curSequenceName = "";
        private bool _canSetHeat = false; //需不需要PM开始停止加热(TMRobot从LoadLock开始取盘)

        private bool _isModuleErrorPrevious;
        private bool[] _isPMErrorPrevious = new bool[4];

        private ushort _debugger2 = 0;
        private ushort _debugger3 = 0;
        private ushort _debugger4 = 0;
        private ushort _debugger5 = 0;
        private ushort _debugger6 = 0;
        private ushort _debugger7 = 0;
        private ushort _debugger8 = 0;

        private R_TRIG _trigJobComplete = new R_TRIG();
        private R_TRIG _loadLockFinishedTrig = new R_TRIG();  //LoadLock完成后充气需要发出蜂鸣
        private R_TRIG _loadLockStartTrig = new R_TRIG();  //LoadLock放入Wafer后需要Purge
        private R_TRIG _updateAutoJobLocation = new R_TRIG(); //需要向数据库更新Wafer位置
        private string _pm1WaferStaus = "";

        public AutoTransfer()
        {

            DATA.Subscribe("Scheduler.IsCycleMode", () => _isCycleMode);
            DATA.Subscribe("Scheduler.CycledCount", () => _cycledCount);
            DATA.Subscribe("Scheduler.CycleSetPoint", () => _cycleSetPoint);
            DATA.Subscribe("Scheduler.RecipeName", () => _curRecipeName);
            DATA.Subscribe("Scheduler.SequenceName", () => _curSequenceName);

            DATA.Subscribe("LoadLock.LocalJobName", () =>
            {
                var jb = _lstControlJobs.Find(x => x.Module == "LoadLock");
                if (jb != null)
                    return jb.Name;
                return "";
            });
            DATA.Subscribe("LoadLock.LocalJobStatus", () =>
            {
                var jb = _lstControlJobs.Find(x => x.Module == "LoadLock");
                if (jb != null)
                    return jb.State.ToString();
                return "";
            });
        }

        public bool HasJobRunning
        {
            get { return _lstControlJobs.Count > 0; }
        }


        public void Clear()
        {
            _tmRobot.ResetTask();
            foreach (var pm in _lstPms)
            {
                pm.ResetTask();
            }
            foreach (var ll in _lstLls)
            {
                ll.ResetTask();
            }
            _buffer.ResetTask();
            _preHeat.ResetTask();

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

        public void GetConfig()
        {
            _cycledCount = 0;
            _isPmAInstal = SC.GetValue<bool>("System.SetUp.IsPM1Installed");
            _isPmBInstal = SC.GetValue<bool>("System.SetUp.IsPM2Installed");

            _isCycleMode = SC.GetValue<bool>("System.IsCycleMode");
            _cycleSetPoint = _isCycleMode ? SC.GetValue<int>("System.CycleCount") : 0;

            foreach (var pm in _lstPms)
            {
                pm.GetConfigInfo();
            }
        }

        #region Job Management

        public void CreateJob(Dictionary<string, object> param)
        {
            //_lstControlJobs = new List<ControlJobInfo>();
            //_lstProcessJobs = new List<ProcessJobInfo>();

            string[] slotSequence = (string[])param["SlotSequence"];
            string jobId = (string)param["JobId"] + DateTime.Now.ToString("yyyyMMddHHmmss");
            string module = (string)param["Module"];
            bool autoStart = (bool)param["AutoStart"];


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

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

            bool enableGroupBySequence = SC.GetValue<bool>("System.Scheduler.GroupWaferBySequence");

            for (int i = 0; i < 1; i++)
            {
                if (string.IsNullOrEmpty(slotSequence[i]) || string.IsNullOrEmpty(slotSequence[i].Trim()))
                    continue;

                string groupName = i.ToString();
                indexSequence[groupName] = slotSequence[i];

                if (!seqSlot.ContainsKey(groupName))
                {
                    seqSlot[groupName] = new bool[1];
                }

                if (!seqSlotWafers.ContainsKey(groupName))
                {
                    seqSlotWafers[groupName] = new List<int>();
                }

                seqSlot[groupName][i] = true;
                seqSlotWafers[groupName].Add(i);
            }

            if (seqSlotWafers.Count == 0)
            {
                EV.PostWarningLog(LogSource, $"Can not create job, no wafer assigned");
                return;
            }

            List<ProcessJobInfo> pjs = new List<ProcessJobInfo>();
            string[] seqs = seqSlot.Keys.ToArray();

            List<string> pjIDs = new List<string>();
            for (int i = 0; i < seqs.Length; i++)
            {
                var name = jobId + "_" + (i + 1);

                if (!CreateProcessJob(name, indexSequence[seqs[i]], seqSlotWafers[seqs[i]], autoStart)) //ProcessJob创建失败直接返回，不再创建ControlJob
                    return;

                pjIDs.Add(name);
            }

            if (!CreateControlJob(jobId, module, pjIDs, autoStart))
            {
                foreach (var pjName in pjIDs)
                {
                    var pj = _lstProcessJobs.FirstOrDefault(x => x.Name == pjName);
                    if (pj != null)
                        _lstProcessJobs.Remove(pj);
                }
            }

            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0);
            if (wafer != null)
            {
                string recipeName = _curRecipeName;
                if (recipeName.IndexOf(@"\") > 0)
                {
                    recipeName = recipeName.Substring(recipeName.LastIndexOf(@"\") + 1);
                }
                AutoJobRecorder.Add(wafer.InnerId.ToString(), recipeName, (string)param["JobId"], ModuleName.LoadLock.ToString(), GetWaferStatue(wafer));
            }
        }

        public bool CreateControlJob(string jobId, string module, List<string> pjIDs, bool isAutoStart)
        {
            if (_lstControlJobs.Exists(x => x.Name == jobId))
            {
                EV.PostWarningLog(LogSource, $"{jobId} is already created");
                return false;
            }

            if (_lstProcessJobs.Count <= 0) //判断上一步ProcessJob是否创建成功
            {
                EV.PostWarningLog(LogSource, $"process job is not exist");
                return false;
            }

            ControlJobInfo cj = new ControlJobInfo();
            cj.Name = jobId;
            cj.Module = module;
            cj.SetState(EnumControlJobState.WaitingForStart);


            int totalWafer = 0;
            foreach (var pjName in pjIDs)
            {
                var pj = _lstProcessJobs.FirstOrDefault(x => x.Name == pjName);
                if (pj == null)
                {
                    LOG.Info($"not find {pjName} while create control job");
                    continue;
                }

                var slotWafers = new List<Tuple<ModuleName, int>>();
                foreach (var slotWafer in pj.SlotWafers)
                {
                    if (!WaferManager.Instance.CheckHasWafer(module, slotWafer.Item2))
                    {
                        EV.PostWarningLog(LogSource, $"job wafer: {module} slot {slotWafer.Item2 + 1} not in the carrier");
                        return false;
                    }
                    if (!WaferManager.Instance.CheckWafer(ModuleHelper.Converter(module), slotWafer.Item2, WaferStatus.Normal))
                    {
                        EV.PostWarningLog(LogSource, $"job wafer: {module} slot {slotWafer.Item2 + 1} status is {WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), slotWafer.Item2).Status}");
                        return false;
                    }
                    if (WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), slotWafer.Item2).ProcessState != EnumWaferProcessStatus.Idle)
                    {
                        EV.PostWarningLog(LogSource, $"job wafer: {module} slot {slotWafer.Item2 + 1} process status is {WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), slotWafer.Item2).ProcessState}");
                        return false;
                    }

                    slotWafers.Add(Tuple.Create(ModuleHelper.Converter(module), slotWafer.Item2));

                    totalWafer++;
                }

                pj.ControlJobName = jobId;

                cj.ProcessJobNameList.Add(pj.Name);
                pj.SlotWafers = slotWafers;
                foreach (var pjSlotWafer in pj.SlotWafers)
                {
                    WaferInfo wafer = WaferManager.Instance.GetWafer(pjSlotWafer.Item1, pjSlotWafer.Item2);

                    WaferDataRecorder.SetCjInfo(wafer.InnerId.ToString(), cj.InnerId.ToString());
                    WaferDataRecorder.SetWaferSequence(wafer.InnerId.ToString(), pj.Sequence.Name);
                    WaferDataRecorder.SetWaferLotId(wafer.InnerId.ToString(), jobId);
                }
            }

            _lstControlJobs.Add(cj);

            CarrierInfo carrier = CarrierManager.Instance.GetCarrier(cj.Module);
            JobDataRecorder.StartCJ(cj.InnerId.ToString(), null, cj.Name, cj.Module, cj.Module, totalWafer);

            return true;
        }

        public bool CreateProcessJob(string jobId, string sequenceName, List<int> slotNumbers/*0 based*/, bool isAutoStart)
        {
            var sequenceInfo = SequenceInfoHelper.GetInfo(sequenceName);

            #region 模块和顺序检查
            if (!CheckSequenceReady(sequenceInfo, out string reason))
            {
                EV.PostWarningLog(LogSource, reason);
                return false;
            }
            #endregion

            var slotWafers = new List<Tuple<ModuleName, int>>();
            foreach (var slot in slotNumbers)
            {
                slotWafers.Add(Tuple.Create(ModuleName.System, slot));
            }

            ProcessJobInfo pj = new ProcessJobInfo();
            pj.Name = jobId;
            pj.Sequence = sequenceInfo;
            pj.SlotWafers = slotWafers;
            pj.SetState(EnumProcessJobState.Queued);

            _lstProcessJobs.Add(pj);

            return true;
        }


        internal void StopJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                EV.PostWarningLog(LogSource, $"stop job rejected, not found job with id {jobName}");
                return;
            }

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

            if (_cycleSetPoint > 0)
            {
                _cycleSetPoint = _cycledCount;
            }
        }

        internal void AbortJob(string jobName)
        {
            //ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            //if (cj == null)
            //{
            //    EV.PostWarningLog(LogSource, $"abort job rejected, not found job with id {jobName}");
            //    return;
            //}
            if (_lstControlJobs.Count == 0)
            {
                return;
            }
            ControlJobInfo cj = _lstControlJobs[_lstControlJobs.Count - 1];
            int unprocessed_cj = 0;
            int aborted_cj = 0;

            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++;
                            unprocessed_cj++;
                        }
                    }
                    JobDataRecorder.EndPJ(pj.InnerId.ToString(), aborted, unprocessed);
                }
            }

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

            _lstControlJobs.Remove(cj);

            JobDataRecorder.EndCJ(cj.InnerId.ToString(), aborted_cj, unprocessed_cj);
        }

        public void ResumeJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                EV.PostWarningLog(LogSource, $"resume job rejected, not found job with id {jobName}");
                return;
            }

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

        internal void PauseJob(string jobName)
        {
            ControlJobInfo cj = _lstControlJobs.Find(x => x.Name == jobName);
            if (cj == null)
            {
                EV.PostWarningLog(LogSource, $"pause job rejected, not found job with id {jobName}");
                return;
            }

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

        internal void StartJob(string jobName)
        {
            GetConfig();

            if (_lstControlJobs.Count < 0)
            {
                return;
            }

            foreach (ControlJobInfo cj in _lstControlJobs)
            {
                if (cj == null)
                {
                    EV.PostWarningLog(LogSource, $"start job rejected, not found job with id {jobName}");
                    return;
                }
                if (cj.State == EnumControlJobState.WaitingForStart)
                {
                    cj.SetState(EnumControlJobState.Executing);
                }
                _loadLockStartTrig.RST = true;
                _loadLockFinishedTrig.RST = true;
            }
        }
        #endregion

        /// <summary>
        /// Start Auto Transfer
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public Result Start(params object[] objs)
        {
            GetConfig();

            _cycledWafer = 0;
            _cycledCount = 0;
            _totalWaferWhenStart = StatsDataManager.Instance.GetValue(StatsNameTotalRunningWafer);

            bool hasPmOnline = false;
            foreach (var schedulerPm in _lstPms)
            {
                if (schedulerPm.IsOnline && !schedulerPm.IsError)
                {
                    hasPmOnline = true;
                    break;
                }
            }

            if (!hasPmOnline)
            {
                EV.PostWarningLog("Scheduler", "can not change to auto mode, at least one process chamber be online and no error");
                return Result.FAIL;
            }

            if (!_tmRobot.IsOnline || _tmRobot.IsError)
            {
                EV.PostWarningLog("Scheduler", "can not change to auto mode, TM robot should be online and no error");
                return Result.FAIL;
            }

            return Result.RUN;
        }

        public Result Monitor()
        {
            ControlJobInfo cjActive = _lstControlJobs.Find(x => x.State == EnumControlJobState.Executing);
            if (cjActive != null)
            {
                MonitorModuleTasks();

                MonitorAutoJobStatus();

                MonitorPmPreTasks();
            }

            MonitorJobTasks();

            MonitorCleanTasks();

            return Result.RUN;
        }

        #region Job task
        public Result MonitorJobTasks()
        {
            UpdateProcessJobStatus();

            UpdateControlJobStatus();

            StartNewJob();

            //_trigJobComplete.CLK = CheckJobComplete();
            //if (_trigJobComplete.Q)
            //{
            //    _loadlock.SetJobStatue();
            //    return Result.DONE;
            //}

            return Result.RUN;
        }

        public Result MonitorCleanTasks()
        {
            foreach (var pm in _lstPms)
            {
                pm.MonitorCleanTasks();
            }
            return Result.RUN;
        }

        public Result MonitorPmPreTasks()
        {
            //检查
            if (CheckWaferNeedProcess(_loadlock.Module, 0))
            {
                string pmModule = GetProcessModule(_loadlock.Module, 0);
                if (pmModule != "" && WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(pmModule), 0))
                {
                    foreach (var pm in _lstPms)
                    {
                        if (pm.Module.ToString() == pmModule && pm.CurrentWaferID == "")
                        {
                            //设置需要运行Pre和Complete Recipe的内容及相关的ProcessID
                            string waferID = WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0).WaferID;

                            bool enbalePre = false;
                            bool enbaleComplete = false;
                            string preRecipe = "";
                            string completeRecipe = "";

                            if (GetPreCompleteRecipeInfo(_loadlock.Module, 0, out enbalePre, out enbaleComplete, out preRecipe, out completeRecipe))
                            {
                                pm.SetCleanInfo(waferID, enbalePre, enbaleComplete, preRecipe, completeRecipe);
                            }
                        }
                    }
                }
            }


            foreach (var pm in _lstPms)
            {
                pm.MonitorClean();
            }

            return Result.RUN;
        }

        protected bool CheckAllWaferReturned(ProcessJobInfo pj, bool checkAllProcessed)
        {
            for (int i = 0; i < pj.SlotWafers.Count; ++i)
            {
                WaferInfo wafer = WaferManager.Instance.GetWafer(pj.SlotWafers[i].Item1, pj.SlotWafers[i].Item2);
                if (wafer.IsEmpty)
                    return false;
                if (checkAllProcessed && CheckWaferNeedProcess(pj.SlotWafers[i].Item1, pj.SlotWafers[i].Item2))
                    return false;
                if (wafer.ProcessJob == null || wafer.ProcessJob.InnerId != pj.InnerId)
                {
                    return false;
                }
            }

            return true;
        }

        protected bool CheckAllDummyWaferReturned()
        {
            foreach (var schedulerPm in _lstPms)
            {
                if (WaferManager.Instance.CheckWaferIsDummy(schedulerPm.Module, 0))
                    return false;
            }

            if (WaferManager.Instance.CheckWaferIsDummy(_tmRobot.Module, 0))
                return false;

            if (WaferManager.Instance.CheckWaferIsDummy(_tmRobot.Module, 1))
                return false;

            return true;
        }

        protected bool CheckAllPmCleaned(ProcessJobInfo pj)
        {
            foreach (var schedulerPm in _lstPms)
            {
                if (CheckNeedRunClean(schedulerPm.Module, out _, out _))
                {
                    foreach (var sequenceStepInfo in pj.Sequence.Steps)
                    {
                        if (sequenceStepInfo.StepModules.Contains(schedulerPm.Module))
                            return false;
                    }
                }
            }


            return true;
        }

        private void UpdateProcessJobStatus()
        {
            foreach (var pj in _lstProcessJobs)
            {
                if (pj.State == EnumProcessJobState.Processing)
                {
                    if (CheckAllWaferReturned(pj, true) && CheckAllPmCleaned(pj) && CheckAllDummyWaferReturned() && _tmRobot.IsAvailable && _loadlock.IsAvailable)
                    {
                        if (CheckWaferSequenceStepDone(ModuleName.LoadLock, 0))
                        {
                            pj.SetState(EnumProcessJobState.ProcessingComplete);
                            JobDataRecorder.EndPJ(pj.InnerId.ToString(), 0, 0);
                        }
                    }
                }
                else if (pj.State == EnumProcessJobState.Stopping)
                {
                    if (CheckAllWaferReturned(pj, false) && CheckAllPmCleaned(pj) && CheckAllDummyWaferReturned() && _tmRobot.IsAvailable && _loadlock.IsAvailable)
                    {
                        if (CheckWaferSequenceStepDone(ModuleName.LoadLock, 0))
                        {
                            pj.SetState(EnumProcessJobState.ProcessingComplete);
                            JobDataRecorder.EndPJ(pj.InnerId.ToString(), 0, 0);
                        }
                    }
                }
            }
        }

        private void UpdateControlJobStatus()
        {
            if (_lstControlJobs.Count == 0)
                return;

            List<ControlJobInfo> cjRemoveList = new List<ControlJobInfo>();
            foreach (var cj in _lstControlJobs)
            {
                if (cj.State == EnumControlJobState.Completed)
                {
                    _lstControlJobs.Remove(cj);
                    break;
                }
                else 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.Error($"Not find pj named {pjName} in {cj.Name}");
                            continue;
                        }
                        if (pj.State != EnumProcessJobState.Complete && pj.State != EnumProcessJobState.ProcessingComplete)
                        {
                            allPjCompleted = false;
                            break;
                        }
                    }

                    if (allPjCompleted)
                    {
                        //Cycle模式下执行+1操作
                        if (_isCycleMode && _cycledCount < _cycleSetPoint)
                        {
                            _cycledCount++;

                            if (_cycledCount < _cycleSetPoint)
                            {
                                foreach (var pjName in cj.ProcessJobNameList)
                                {
                                    var pj = _lstProcessJobs.Find(x => x.Name == pjName);
                                    if (pj == null)
                                    {
                                        LOG.Error($"Not find pj named {pjName} in {cj.Name}");
                                        continue;
                                    }
                                    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
                        {
                            cj.SetState(EnumControlJobState.Completed);
                        }
                    }
                }
            }
        }

        private void StartNewJob()
        {
            foreach (var cj in _lstControlJobs)
            {
                if (cj.State == EnumControlJobState.Executing)
                {
                    foreach (var pjName in cj.ProcessJobNameList)
                    {
                        var pj = _lstProcessJobs.Find(x => x.Name == pjName);
                        if (pj == null)
                        {
                            LOG.Error($"Not find pj named {pjName} in {cj.Name}");
                            continue;
                        }

                        if (pj.State == EnumProcessJobState.Queued)
                        {
                            ActiveProcessJob(pj);
                        }
                    }
                }
            }
        }

        public bool CheckAllJobDone()
        {
            //_trigLp1JobComplete.CLK = _isUnloadFoup && CheckJobComplete(ModuleName.LP1.ToString()) && !IsRemoteConnected;
            //if (_trigLp1JobComplete.Q)
            //{
            //    CheckLp1AutoGaslinePurge();                         //qiming 20210429
            //}

            //_trigLp2JobComplete.CLK = _isUnloadFoup && CheckJobComplete(ModuleName.LP2.ToString()) && !IsRemoteConnected;
            //if (_trigLp2JobComplete.Q)
            //{          
            //    CheckLp2AutoGaslinePurge();                         //qiming 20210429
            //}

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

            if (WaferManager.Instance.CheckHasWafer(ModuleName.LoadLock, 0) && _lstControlJobs.Count == 0)
            {
                if (WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0).ProcessState == EnumWaferProcessStatus.Completed)
                {
                    AutoJobRecorder.EndJob(WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0).InnerId.ToString());
                    _loadlock.SetJobStatue();
                    EV.PostWarningLog("Scheduler", "ControlJob Finished!");
                    return true;
                }
            }
            return false;
        }

        public void MonitorAutoJobStatus()
        {
            _updateAutoJobLocation.CLK = _tmRobot.IsAvailable;
            if (_updateAutoJobLocation.Q)
            {
                WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleName.PM1, 0);
                if (wafer != null)
                {
                    AutoJobRecorder.UpdatePosition(wafer.InnerId.ToString(), ModuleName.PM1.ToString(), GetWaferStatue(wafer));
                }

                WaferInfo wafer1 = WaferManager.Instance.GetWafer(ModuleName.TMRobot, 0);
                if (wafer1 != null)
                {
                    AutoJobRecorder.UpdatePosition(wafer1.InnerId.ToString(), ModuleName.TM.ToString(), GetWaferStatue(wafer1));
                }

                WaferInfo wafer2 = WaferManager.Instance.GetWafer(ModuleName.Buffer, 0);
                if (wafer2 != null)
                {
                    AutoJobRecorder.UpdatePosition(wafer2.InnerId.ToString(), ModuleName.Buffer.ToString(), GetWaferStatue(wafer2));
                }

                WaferInfo wafer3 = WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0);
                if (wafer3 != null)
                {
                    AutoJobRecorder.UpdatePosition(wafer3.InnerId.ToString(), ModuleName.LoadLock.ToString(), GetWaferStatue(wafer3));
                }
            }
        }

        #region 组件检查

        private bool CheckSequenceReady(SequenceInfo seq, out string reason)
        {
            reason = "";
            bool pmIsReady = false;
            bool bufferIsReady = false;
            for (int i = 0; i < seq.Steps.Count; i++)
            {
                SequenceStepInfo stepInfo = seq.Steps[i];
                foreach (var module in stepInfo.StepModules)
                {
                    if ((module == ModuleName.PM1 || module == ModuleName.PMA))
                    {
                        if (!_isPmAInstal)
                        {
                            reason = "Sequence stepinfo contains a no installed PM";
                            return false;
                        }
                        _curSequenceName = seq.Name;
                        _curRecipeName = seq.Steps[i].RecipeName;       //顺便获取最新的Recipe名字
                        pmIsReady = true;

                        if (!SicPM.RecipeExecutions.RecipeParser.CheckDataAvalible(_curRecipeName, module.ToString(), out string reason1))
                        {
                            EV.PostWarningLog(LogSource, reason1);
                            //return false;
                        }
                    }
                    else if ((module == ModuleName.PM2 || module == ModuleName.PMB))
                    {
                        if (!_isPmBInstal)
                        {
                            reason = "Sequence stepinfo contains a no installed PM";
                            return false;
                        }
                        _curSequenceName = seq.Name;
                        _curRecipeName = seq.Steps[i].RecipeName;       //顺便获取最新的Recipe名字
                        pmIsReady = true;
                        if (!SicPM.RecipeExecutions.RecipeParser.CheckDataAvalible(_curRecipeName, module.ToString(), out string reason1))
                        {
                            reason = "Recipe data is error!";
                            return false;
                        }
                    }

                    if (module == ModuleName.Buffer)
                    {
                        if (!pmIsReady)
                        {
                            reason = "Sequence stepinfo error,The buffer step must after the PM step";
                            return false;
                        }
                        bufferIsReady = true;
                    }
                }

                
            }
            if (!pmIsReady)
            {
                reason = "Sequence stepinfo must contain a PM step";
                return false;
            }
            if (!bufferIsReady)
            {
                reason = "Sequence stepinfo must contain a Buffer step";
                return false;
            }
            return true;

        }

        #endregion

        private bool ActiveProcessJob(ProcessJobInfo pj)
        {
            _lstPmsCurrentSequence.Clear();
            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) && _lstPms.Exists(x => x.Module == module))
                    {
                        _lstPmsCurrentSequence.Add(_lstPms.Find(x => x.Module == module));
                    }
                }
            }

            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(), null, cj.InnerId.ToString(), pj.Name, cj.Module, cj.Module, pj.SlotWafers.Count);
            pj.SetState(EnumProcessJobState.Processing);

            return true;
        }

        private bool CheckJobComplete(string lp = null)
        {
            if (_lstProcessJobs.Count == 0)
                return false;

            if (_lstControlJobs.Count == 0)
                return false;

            if (_isCycleMode && _cycledCount < _cycleSetPoint)
                return false;

            if (lp != null)
            {
                var cj = _lstControlJobs.Find(x => x.Module == lp);
                if (cj == null)
                    return false;
            }

            foreach (var pj in _lstProcessJobs)
            {
                if (lp == null)
                {
                    if (pj.State != EnumProcessJobState.ProcessingComplete)
                    {
                        return false;
                    }
                }
            }

            foreach (var cj in _lstControlJobs)
            {
                if (lp == null)
                {
                    if (cj.State != EnumControlJobState.Completed)
                    {
                        return false;
                    }
                }
                else
                {
                    if (cj.Module == lp && cj.State != EnumControlJobState.Completed)
                    {
                        return false;
                    }
                }
            }

            return true;
        }
        #endregion

        #region Module task

        public Result MonitorModuleTasks()
        {
            MonitorPMTask();

            MonitorTmRobotTask();

            MonitorLoadLockTask();

            MonitorBufferTask();

            return Result.RUN;
        }

        private void MonitorBufferTask()
        {
            if (WaferManager.Instance.CheckHasWafer(_buffer.Module, 0) && CheckWaferNextStepIsBuffer(_buffer.Module, 0) && _tmRobot.IsAvailable && _buffer.IsAvailable)
            {
                //判断冷却方式是温度还是时间
                bool coolingTypeIsTime = CheckCoolingTypeIsTime(_buffer.Module, 0);
                int coolingValue = GetWaferSequenceBufferCoolingValue(_buffer.Module, 0);

                _buffer.Cooling(coolingTypeIsTime, coolingValue);
                WaferManager.Instance.GetWafer(_buffer.Module, 0).NextSequenceStep++;
            }
        }

        private bool _loadLockFinishedPurgeOver = false;
        private bool _loadLockFinishedVent = false;

        private void MonitorLoadLockTask()
        {
            if (!_tmRobot.IsAvailable || !_loadlock.IsAvailable)
            {
                return;
            }

            if (CheckWaferSequenceStepDone(ModuleName.LoadLock, 0) && WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0).ProcessState == EnumWaferProcessStatus.Completed)
            {
                if (!_loadlock.CheckAtAtm())
                {
                    if (_isCycleMode && _cycledCount < _cycleSetPoint)
                    {
                        return;
                    }
                    else
                    {
                        if (!_loadLockFinishedPurgeOver)
                        {
                            _loadlock.Purge();
                            _loadLockFinishedPurgeOver = true;
                            return;
                        }
                    }
                }

                if (_loadLockFinishedPurgeOver)
                {
                    if (!_loadLockFinishedVent)
                    {
                        _loadlock.Vent();
                        _loadLockFinishedVent = true;
                        return;
                    }

                    _trigJobComplete.CLK = _loadLockFinishedVent;
                    if (_trigJobComplete.Q)
                    {
                        AutoJobRecorder.EndJob(WaferManager.Instance.GetWafer(ModuleName.LoadLock, 0).InnerId.ToString());
                        _loadlock.SetJobStatue();
                    }
                }
            }
            else
            {
                if (WaferManager.Instance.CheckHasWafer(_loadlock.Module, 0))
                {
                    //第一次Start,LoadLock需要执行Purge
                    _loadLockStartTrig.CLK = true;
                    if (_loadLockStartTrig.Q)
                    {
                        //_loadLockFinishedPurgeOver = false;
                        _loadlock.Purge();
                        return;
                    }

                    if (!_loadlock.IsReadyForPick(ModuleName.TMRobot, 0))
                    {
                        _loadlock.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Pick, 0);
                    }
                }
                else
                {
                    if (!_loadlock.IsReadyForPlace(ModuleName.TMRobot, 0))
                    {
                        _loadlock.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Place, 0);
                    }
                }
            }


        }

        private void MonitorPMTask()
        {
            foreach (var pm in _lstPms)
            {
                WaferInfo wafer1 = WaferManager.Instance.GetWafer(pm.Module, 0);
                if (wafer1 == null)
                {
                    _pm1WaferStaus = "";
                }
                else if (wafer1.ProcessState.ToString() != _pm1WaferStaus)
                {
                    _pm1WaferStaus = wafer1.ProcessState.ToString();
                    AutoJobRecorder.UpdatePosition(wafer1.InnerId.ToString(), ModuleName.PM1.ToString(), GetWaferStatue(wafer1));
                }


                if (!pm.IsAvailable)
                    continue;

                if (WaferManager.Instance.CheckHasWafer(pm.Module, 0))
                {
                    if (CheckNeedRunClean(pm.Module, out bool withWafer, out string recipe) && withWafer
                          && WaferManager.Instance.GetWafer(pm.Module, 0).Status == WaferStatus.Dummy
                          && WaferManager.Instance.GetWafer(pm.Module, 0).ProcessState == EnumWaferProcessStatus.Wait)
                    {
                        pm.Process(recipe, true, withWafer);
                        continue;
                    }

                    if (CheckWaferNeedProcess(pm.Module, 0, pm.Module))
                    {
                        WaferInfo wafer = WaferManager.Instance.GetWafer(pm.Module, 0);
                        if (pm.Process(wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].RecipeName, false, true))
                        {
                            pm.SetCurrentRunCount();
                            WaferManager.Instance.GetWafer(pm.Module, 0).NextSequenceStep++;
                            continue;
                        }
                    }
                    else
                    {
                        if (!pm.IsReadyForPick(ModuleName.TMRobot, 0))
                        {
                            pm.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Pick, 0);
                        }
                    }
                }
                else
                {
                    if (CheckNeedRunClean(pm.Module, out bool withWafer, out string recipe) && !withWafer)
                    {
                        pm.Process(recipe, true, withWafer);
                        continue;
                    }

                    if (!pm.IsReadyForPlace(ModuleName.TMRobot, 0))
                    {
                        pm.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Place, 0);
                        return;
                    }

                    //if (!pm.CheckHeatIsDisbale() && _canSetHeat)
                    //{
                    //    pm.SetHeatDisable();
                    //    _canSetHeat = false;
                    //}
                }
            }
        }

        private void MonitorTmRobotTask()
        {
            if (!_tmRobot.IsAvailable)
                return;

            //TM robot is idle, release all the target 
            foreach (var ll in _lstLls)
            {
                if (ll.IsWaitTransfer(ModuleName.TMRobot))
                    ll.StopWaitTransfer(ModuleName.TMRobot);
            }

            foreach (var pm in _lstPms)
            {
                if (pm.IsWaitTransfer(ModuleName.TMRobot))
                    pm.StopWaitTransfer(ModuleName.TMRobot);
            }

            if (_buffer.IsWaitTransfer(ModuleName.TMRobot))
                _buffer.StopWaitTransfer(ModuleName.TMRobot);


            MonitorTmRobotLoadLockTask();

            MonitorTmRobotBufferTask();

            MonitorTmRobotPMTask();

            //MonitorTmRobotPreHeatTask();

        }

        private void MonitorTmRobotLoadLockTask()
        {
            if (!_tmRobot.IsAvailable)
                return;

            //place to ll
            bool blade0HasWaferAndProcessed = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) &&
                                               !CheckWaferNeedProcess(ModuleName.TMRobot, 0) &&
                                         !(WaferManager.Instance.GetWafer(ModuleName.TMRobot, 0).Status == WaferStatus.Dummy)
                                         && CheckWaferSequenceStepDone(ModuleName.TMRobot, 0);

            if (blade0HasWaferAndProcessed && WaferManager.Instance.CheckNoWafer(_loadlock.Module, 0))
            {
                Hand placeBlade = Hand.Blade1;

                SchedulerLoadLock placeLL = null;
                int placeSlot = Int32.MinValue;

                if (_loadlock.IsAvailable && _loadlock.IsReadyForPlace(ModuleName.TMRobot, 0))
                {
                    int slot = WaferManager.Instance.GetWafer(_loadlock.Module, 0).OriginSlot;
                    if (slot > placeSlot)
                    {
                        placeLL = _loadlock;
                        placeSlot = slot;
                    }
                }

                if (placeLL != null)
                {
                    if (placeLL.IsReadyForPlace(ModuleName.TMRobot, 0))
                    {
                        if (_tmRobot.Place(placeLL.Module, 0, placeBlade))
                        {
                            _loadLockFinishedPurgeOver = false;
                            _loadLockFinishedVent = false;

                            placeLL.WaitTransfer(ModuleName.TMRobot);
                            return;
                        }
                    }
                }
            }

            if (!_tmRobot.IsAvailable)
                return;

            //pick from ll
            if (WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, 0))
            {
                Hand pickBlade = Hand.Blade1;

                SchedulerLoadLock pickLL = null;
                int pickSlot = Int32.MaxValue;

                if (!_loadlock.IsAvailable
                    || !_loadlock.IsReadyForPick(ModuleName.TM, 0)
                    || !WaferManager.Instance.CheckHasWafer(_loadlock.Module, 0)
                    || !CheckWaferNeedProcess(_loadlock.Module, 0)
                    || !CheckWaferProcessModuleIsAvailable(_loadlock.Module, 0))
                    return;


                bool findChamberToProcess = false;
                foreach (var pm in _lstPms)
                {
                    if (!pm.IsAvailable || WaferManager.Instance.CheckHasWafer(pm.Module, 0) || CheckNeedRunClean(pm.Module, out _, out _))
                        continue;

                    bool llWaferProcessIn = CheckWaferNextProcessIn(_loadlock.Module, 0, pm.Module);
                    bool robotWaferProcessIn = CheckWaferNextProcessIn(ModuleName.TMRobot, (int)pickBlade, pm.Module);

                    if (!llWaferProcessIn)
                        continue;
                    if (robotWaferProcessIn)
                        continue;

                    findChamberToProcess = true;
                }


                string chamberToProcess = GetProcessModule(_loadlock.Module, 0);
                foreach (var pm in _lstPms)
                {
                    if (pm.Module.ToString() == chamberToProcess)
                    {
                        if (pm.CurrentWaferID != "" && pm.CurrentWaferID != WaferManager.Instance.GetWafer(_loadlock.Module, 0).WaferID)
                        {
                            //return;
                        }
                    }
                }

                if (!findChamberToProcess)
                    return;


                int slot = WaferManager.Instance.GetWafer(_loadlock.Module, 0).OriginSlot;
                if (slot < pickSlot)
                {
                    pickLL = _loadlock;
                    pickSlot = slot;
                }

                if (pickLL != null)
                {
                    if (pickLL.IsReadyForPick(ModuleName.TMRobot, 0))
                    {
                        if (_tmRobot.Pick(pickLL.Module, 0, pickBlade))
                        {
                            pickLL.WaitTransfer(ModuleName.TMRobot);
                            _canSetHeat = true;
                            return;
                        }
                    }
                }
            }
        }

        private void MonitorTmRobotBufferTask()
        {
            if (!_tmRobot.IsAvailable || !_buffer.IsAvailable)
                return;

            //place to Buffer (工艺做完，Sequence下一步是Buffer)
            bool blade0HasWaferAndProcessed = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) &&
                                               !CheckWaferNeedProcess(ModuleName.TMRobot, 0, _pm1.Module) &&
                                               (CheckWaferNextStepIsBuffer(ModuleName.TMRobot, 0) || (!CheckWaferNextStepIsBuffer(ModuleName.Buffer, 0) && !CheckWaferNextStepIsBuffer(ModuleName.LoadLock, 0) && WaferManager.Instance.CheckHasWafer(ModuleName.LoadLock, 0)));
            //place to buffer
            if (blade0HasWaferAndProcessed && WaferManager.Instance.CheckNoWafer(ModuleName.Buffer, 0))
            {
                Hand placeBlade = Hand.Blade1;

                if (_buffer.IsReadyForPlace(ModuleName.TMRobot, 0))
                {
                    if (_tmRobot.Place(_buffer.Module, 0, placeBlade))
                    {
                        _buffer.WaitTransfer(ModuleName.TMRobot);
                        return;
                    }
                }

            }

            //pick from buffer
            if (WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, 0) && WaferManager.Instance.CheckNoWafer(ModuleName.LoadLock, 0) && WaferManager.Instance.CheckHasWafer(ModuleName.Buffer, 0))
            {
                if (_loadlock.HasWafer(0))
                {
                    return;
                }

                Hand pickBlade = Hand.Blade1;


                if (!_buffer.CheckTaskDone() || !CheckWaferSequenceStepDone(_buffer.Module, 0))
                {
                    return;
                }

                bool waferHasJob = CheckBufferWaferHasJob();
                if (!waferHasJob && !_buffer.IsReadyForPick(ModuleName.TMRobot, 0))
                {
                    return;
                }
                else
                {

                    if (_tmRobot.Pick(_buffer.Module, 0, pickBlade))
                    {
                        _buffer.WaitTransfer(ModuleName.TMRobot);
                        return;
                    }
                }


            }
        }

        private void MonitorTmRobotPMTask()
        {
            if (!_tmRobot.IsAvailable)
                return;

            //place to pm
            bool blade0HasWaferAndNeedProcess = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) &&
                                              CheckWaferNeedProcess(ModuleName.TMRobot, 0);

            if (blade0HasWaferAndNeedProcess)
            {
                _debugger2++;

                foreach (var pm in _lstPms)
                {
                    if (!pm.IsAvailable
                        || !WaferManager.Instance.CheckNoWafer(pm.Module, 0)
                        || !pm.IsReadyForPlace(ModuleName.TMRobot, 0))
                        //|| !pm.CheckTempBelow900())
                        continue;

                    bool cleanRequired = CheckNeedRunClean(pm.Module, out bool withWafer, out _);

                    if (cleanRequired)
                    {
                        if (!withWafer)
                            continue;

                        bool blade0DummyPlace = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) &&
                                           CheckWaferNeedProcess(ModuleName.TMRobot, 0, pm.Module) && WaferManager.Instance.CheckWaferIsDummy(ModuleName.TMRobot, 0);
                        bool blade1DummyPlace = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 1) &&
                                           CheckWaferNeedProcess(ModuleName.TMRobot, 1, pm.Module) && WaferManager.Instance.CheckWaferIsDummy(ModuleName.TMRobot, 1);
                        if (blade0DummyPlace || blade1DummyPlace)
                        {
                            Hand placeBlade = blade0DummyPlace ? Hand.Blade1 : Hand.Blade2;
                            if (blade0DummyPlace && blade1DummyPlace)
                            {
                                if (WaferManager.Instance.GetWafer(ModuleName.TMRobot, 1).OriginSlot <
                                    WaferManager.Instance.GetWafer(ModuleName.TMRobot, 0).OriginSlot)
                                {
                                    placeBlade = Hand.Blade2;
                                }
                            }

                            if (_tmRobot.Place(pm.Module, 0, placeBlade))
                            {
                                pm.WaitTransfer(ModuleName.TMRobot);
                                return;
                            }
                        }

                        continue;
                    }

                    bool blade0Place = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, 0) &&
                                                        CheckWaferNeedProcess(ModuleName.TMRobot, 0, pm.Module);
                    if (blade0Place)
                    {
                        Hand placeBlade = Hand.Blade1;

                        if (_tmRobot.Place(pm.Module, 0, placeBlade))
                        {
                            pm.WaitTransfer(ModuleName.TMRobot);
                            return;
                        }
                    }
                }
            }

            if (!_tmRobot.IsAvailable)
                return;

            //pick from pm
            if (WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, 0))
            {
                _debugger3++;

                Hand pickBlade = Hand.Blade1;

                ModuleName pickPm = ModuleName.System;
                int waferOriginSlot = int.MaxValue;
                foreach (var schedulerPm in _lstPms)
                {
                    //增加温度低于900才能Pick的限制
                    if (!schedulerPm.IsAvailable
                        || WaferManager.Instance.CheckNoWafer(schedulerPm.Module, 0)
                        || CheckWaferNeedProcess(schedulerPm.Module, 0, schedulerPm.Module)
                        || WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)pickBlade))
                        //|| !schedulerPm.CheckTempBelow900())
                        continue;

                    _debugger4++;

                    WaferInfo wafer = WaferManager.Instance.GetWafer(schedulerPm.Module, 0);

                    bool pickAllowed = CheckVacuumWaferHasAvailableTarget(schedulerPm.Module, 0, schedulerPm.Module);

                    if (pickAllowed)
                    {
                        _debugger5++;

                        int slot = wafer.OriginSlot;
                        if (slot < waferOriginSlot)
                        {
                            waferOriginSlot = slot;
                            pickPm = schedulerPm.Module;
                        }
                    }
                }

                if (pickPm != ModuleName.System)
                {
                    _debugger6++;

                    SchedulerModule pm = GetModule(pickPm.ToString());
                    if (pm.IsReadyForPick(ModuleName.TMRobot, 0))
                    {
                        _debugger7++;
                        bool hasWaferNeedRun = CheckWaferNeedProcess(ModuleName.LoadLock, 0) || CheckWaferNeedProcess(ModuleName.TMRobot, 0) || CheckWaferNeedProcess(ModuleName.Buffer, 0);

                        if (_tmRobot.Pick(pm.Module, 0, pickBlade))
                        {
                            _debugger8++;
                            pm.WaitTransfer(ModuleName.TMRobot);

                            return;
                        }
                    }
                }
            }
        }

        #endregion

        #region Logic Check

        private bool CheckNeedRunClean(ModuleName module, out bool withWafer, out string recipeName)
        {
            recipeName = string.Empty;
            withWafer = false;


            return false;
        }

        private bool CheckVacuumWaferHasAvailableTarget(ModuleName waferModule, int waferSlot, ModuleName chamberSwappable)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(waferModule, waferSlot);

            if (CheckWaferNeedProcess(waferModule, waferSlot))
            {
                // Check for an empty PM
                foreach (var pm in _lstPms)
                {
                    if (WaferManager.Instance.CheckNoWafer(pm.Module, 0) || pm.Module == chamberSwappable)
                    {
                        if (pm.IsAvailable == false)
                            continue;

                        if (!CheckWaferNextProcessIn(waferModule, waferSlot, pm.Module))
                            continue;

                        return true;
                    }
                }
            }
            else
            {
                if (WaferManager.Instance.CheckNoWafer(_buffer.Module, 0) && _buffer.IsAvailable)
                {
                    return true;
                }
            }

            return false;
        }

        private bool CheckWaferNextProcessIn(ModuleName waferModule, int waferSlot, ModuleName chamber)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(waferModule, waferSlot);

            if (wafer.ProcessJob == null ||
                wafer.ProcessJob.Sequence == null ||
                wafer.ProcessJob.Sequence.Steps == null ||
                wafer.ProcessJob.Sequence.Steps.Count <= wafer.NextSequenceStep ||
                wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep] == null ||
                wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules == null)
            {
                return false;
            }

            //return wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(chamber);

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

            return false;
        }

        private SequenceInfo GetCurrentSequenceInfo()
        {
            foreach (var pj in _lstProcessJobs)
            {
                if (pj.State == EnumProcessJobState.Processing)
                {
                    return pj.Sequence;
                }
            }

            return null;
        }

        /// <summary>
        /// 判断Buffer的冷却方式是时间还是温度
        /// </summary>
        /// <param name="module"></param>
        /// <param name="slot"></param>
        /// <returns></returns>
        private bool CheckCoolingTypeIsTime(ModuleName module, int slot)
        {
            if (!WaferManager.Instance.CheckHasWafer(module, slot))
                return false;

            WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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

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

            if (wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepParameter["CoolingType"].ToString().ToLower() == "time")
            {
                return true;
            }

            return false;
        }

        private int GetWaferSequenceBufferCoolingValue(ModuleName module, int slot)
        {
            int coolingValue = 0;

            if (!WaferManager.Instance.CheckHasWafer(module, slot))
                return coolingValue;

            WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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

            if (!wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(module))
                return coolingValue;

            int.TryParse(wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepParameter["CoolingValue"].ToString(),
                out coolingValue);
            return coolingValue;
        }

        private bool CheckWaferNextStepIsBuffer(ModuleName module, int slot)
        {
            if (!WaferManager.Instance.CheckHasWafer(module, slot))
                return false;

            WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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

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

            return true;
        }

        private bool CheckWaferNextStepIsLoadLock(ModuleName module, int slot)
        {
            if (!WaferManager.Instance.CheckHasWafer(module, slot))
                return false;

            WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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

            if (!wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Any(m => ModuleHelper.IsLoadLock(m)))
                return false;

            return true;
        }

        private bool CheckWaferNextStepIsTMRobot(ModuleName module, int slot)
        {
            if (!WaferManager.Instance.CheckHasWafer(module, slot))
                return false;

            WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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

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

            return true;
        }

        private bool CheckWaferNextStepIsPM(ModuleName module, int slot)
        {
            if (!WaferManager.Instance.CheckHasWafer(module, slot))
                return false;

            WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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

            if (!wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Any(m => ModuleHelper.IsPm(m)))
                return false;

            return true;
        }

        /// <summary>
        /// 获取前处理和后处理的Recipe信息
        /// </summary>
        /// <param name="module"></param>
        /// <param name="slot"></param>
        /// <returns></returns>
        private bool GetPreCompleteRecipeInfo(ModuleName module, int slot, out bool enablePre, out bool enableComplete, out string preRecipe, out string completeRecipe)
        {
            enablePre = false;
            enableComplete = false;
            preRecipe = "";
            completeRecipe = "";

            try
            {
                if (!WaferManager.Instance.CheckHasWafer(module, slot))
                    return false;

                WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);

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

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


                for (int i = 0; i < wafer.ProcessJob.Sequence.Steps.Count; i++)
                {
                    if (wafer.ProcessJob.Sequence.Steps[i].StepModules.Any(m => ModuleHelper.IsPm(m)))
                    {
                        if (wafer.ProcessJob.Sequence.Steps[i].StepParameter["EnablePre"].ToString().Trim() != "")
                        {
                            enablePre = true;
                        }
                        if (wafer.ProcessJob.Sequence.Steps[i].StepParameter["EnableComplete"].ToString().Trim() != "")
                        {
                            enableComplete = true;
                        }
                        preRecipe = wafer.ProcessJob.Sequence.Steps[i].StepParameter["PretreatmentRecipe"].ToString();
                        completeRecipe = wafer.ProcessJob.Sequence.Steps[i].StepParameter["CompleteRecipe"].ToString();
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
                enablePre = false;
                enableComplete = false;
                preRecipe = "";
                completeRecipe = "";
                return true;
            }
        }

        public bool CheckWaferNeedProcess(ModuleName waferModule, int waferSlot, ModuleName processIn = ModuleName.System)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(waferModule, waferSlot);

            if (wafer.IsEmpty)
                return false;

            if (wafer.Status == WaferStatus.Dummy && wafer.ProcessState == EnumWaferProcessStatus.Wait)
            {
                if (ModuleHelper.IsPm(processIn))
                {
                    return (CheckNeedRunClean(processIn, out bool withWafer, out _) && withWafer);
                }
                return true;
            }

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

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

            if (processIn != ModuleName.System && !wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules
                    .Contains(processIn))
                return false;

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

                if (hasPm)
                    break;
            }

            if (processIn == ModuleName.System && !hasPm)
                return false;

            return true;
        }

        public bool CheckWaferSequenceStepDone(ModuleName waferModule, int waferSlot)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(waferModule, waferSlot);

            if (wafer.IsEmpty)
            {
                return false;
            }
            if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
            {
                return true;
            }

            if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count && wafer.ProcessJob.Sequence.Steps.Count > 0)
            {
                return true;
            }

            return false;
        }

        public bool CheckBufferWaferHasJob()
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleName.Buffer, 0);

            if (wafer.IsEmpty)
            {
                return false;
            }
            if (wafer.ProcessJob == null)
            {
                return false;
            }

            ProcessJobInfo pj = _lstProcessJobs.Find(x => x.InnerId == wafer.ProcessJob.InnerId);
            if (pj == null)
            {
                return false;
            }

            return true;

        }

        public bool CheckWaferProcessModuleIsAvailable(ModuleName waferModule, int waferSlot)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(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;

            //foreach (var module in wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules)
            //{
            //    if (WaferManager.Instance.CheckNoWafer(module, 0)
            //        && _lstPms.Find(x => x.Module == module).IsAvailable
            //        && !CheckNeedRunClean(module, out bool _, out string _))
            //        return true;
            //}

            foreach (var step in wafer.ProcessJob.Sequence.Steps)
            {
                foreach (var module in step.StepModules)
                {
                    if (module.ToString().StartsWith("PM")
                        && WaferManager.Instance.CheckNoWafer(module, 0)
                        && _lstPms.Find(x => x.Module == module).IsAvailable
                        && !CheckNeedRunClean(module, out bool _, out string _))
                        return true;
                }
            }

            return false;
        }

        //获取
        public string GetProcessModule(ModuleName waferModule, int waferSlot)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(waferModule, waferSlot);

            if (wafer.IsEmpty)
                return "";

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

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

            foreach (var step in wafer.ProcessJob.Sequence.Steps)
            {
                foreach (var module in step.StepModules)
                {
                    if (module.ToString().StartsWith("PM")
                        && WaferManager.Instance.CheckNoWafer(module, 0)
                        && _lstPms.Find(x => x.Module == module).IsAvailable
                        && !CheckNeedRunClean(module, out bool _, out string _))
                        return module.ToString();
                }
            }

            return "";
        }

        #endregion



        #region Module error

        public Result MonitorModuleError()
        {
            bool isModuleError = false;
            bool[] isPMError = new bool[4];

            for (int i = 0; i < isPMError.Length; i++)
            {
                isPMError[i] = false;
            }

            if (_tmRobot.IsError)
                isModuleError = true;

            for (int i = 0; i < _lstPms.Count; i++) // PM出错，不影响其他腔体的传片
            {
                if (_lstPms[i].IsError)
                    isPMError[i] = true;
            }

            foreach (var ll in _lstLls)
            {
                if (ll.IsError)
                    isModuleError = true;
            }

            if (isModuleError && !_isModuleErrorPrevious)
            {
                //var jb1 = _lstControlJobs.Find(x => x.Module == "LP1");
                //if (jb1 != null)
                //    PauseJob(jb1.Name);

                //var jb2 = _lstControlJobs.Find(x => x.Module == "LP2");
                //if (jb2 != null)
                //    PauseJob(jb2.Name);
            }
            else if (!isModuleError && _isModuleErrorPrevious)
            {
                Reset();
                //CloseDoor();
            }

            for (int i = 0; i < _lstPms.Count; i++)
            {
                if (!isPMError[i] && _isPMErrorPrevious[i])
                {
                    _lstPms[i].ResetTask();
                }

                _isPMErrorPrevious[i] = isPMError[i];
            }

            _isModuleErrorPrevious = isModuleError;

            return Result.RUN;
        }


        private string GetWaferStatue(WaferInfo wafer)
        {
            if (wafer.ProcessState == EnumWaferProcessStatus.InProcess)
            {
                return "InProcess";
            }
            else if (wafer.ProcessState == EnumWaferProcessStatus.Completed)
            {
                return "Completed";
            }
            else
            {
                return "Idle";
            }
        }

        #endregion

    }
}