using System;
using System.Collections.Generic;
using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData.IoDevice;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Devices;
using Aitex.Core.RT.Device.PmDevices;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using Aitex.Core.Util;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Gem;
using MECF.Framework.Common.SubstrateTrackings;
using SicModules.PMs.Routines.Base;
using MECF.Framework.Common.MECF.Framework.Common.RecipeCenter.Recipe;
using static Aitex.Core.RT.Device.PmDevices.DicMode;

namespace SicModules.PMs.RecipeExecutions
{
    public enum RecipeContinueMode
    {
        None,
        WaferReturnAndJobStop,
        RecipeCompleted,
        StepContinue,
        StepRestart,
        RecipeRestart,
        NextStep,
    }

    public partial class Process : PMBaseRoutine
    {
        enum RoutineStep
        {
            WaitProcess,
        }

        enum RecipeRunningState
        {
            Error,
            RecipeCompleted,
            ExecStep,
            TimeWait,
            ConditionWait,
            StepCompleted,
            Paused,
        }

        private object _recipeLocker = new object();
        private bool _hasRecordRunTime = false;

        private RecipeRunningState _state = RecipeRunningState.ExecStep;
        private RecipeRunningState _pausedState = RecipeRunningState.ExecStep;
        private DeviceTimer _estimatedTimeCalcTimer = new DeviceTimer(); //用于定时计算工艺程序估计的结束时间

        private double _curStepElpasedTimeBeforePaused;

        private double _curStepElpasedTimeBeforePaused2;
        private List<int> _lstSkipSteps = new List<int>();

        public RecipeContinueMode ContinueAction { get; set; }

        public DateTime _recipeStartTime { get; private set; }

        public string CurrentRecipeContent { get; private set; }


        private int _currentStepNumber;

        private int _dummyStepCount;

        public int CurStepTotalLoopCount { get; private set; }

        public double CurStepTotalTime
        {
            get
            {
                if (PmDevice.RecipeRunningInfo.RecipeStepList == null ||
                    PmDevice.RecipeRunningInfo.RecipeStepList.Count == 0 ||
                    _state == RecipeRunningState.RecipeCompleted || _state == RecipeRunningState.Error)
                    return 0;
                return PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime * 1000;
            }
        }


        public int CurrentLoopCount { get; private set; }

        private DeviceTimer _stepTimer = new DeviceTimer();
        private DeviceTimer _stepTimer2 = new DeviceTimer();
        private DeviceTimer _recipeTimer = new DeviceTimer();

        public bool IsPaused { private set; get; }


        private double CurStepLeftTime
        {
            get { return _stepTimer.GetTotalTime() - _stepTimer.GetElapseTime(); }
        }

        public double EstimatedTotalLeftTime { get; private set; }

        private RecipeDBCallback _dbCallback;
        private Fdc _fdc;

        private bool _isDryRun;
        private int _delayTimeDryRun;

        private double _tempOffset;

        private int _currentStepIndex = 99;
        private IoInterLock _pmInterLock;

        private SicServo _pmSicServo = null;

        private bool bAlarm = false; //True-Alarm, False-Warning
        private double fThreshold = 3.0f; //阈值，从配置文件里取
        private int iTimes = -1; //超限次数，设定值
        private int iT = 0; //超限次数计数，实际值

        private double _pressureDifferenceUpperLimit;

        #region Parse

        private bool _isPSUHeaterJumpMode;
        private bool _isSCRHeaterJumpMode;
        private bool _isMFCJumpMode;

        #endregion


        #region Check

        private PeriodicJob _thread;
        private PeriodicJob _threadRotationAlarm;

        private DeviceTimer _rampCalcTimer = new DeviceTimer(); //用于定时获取PC的Ramp

        protected ToleranceChecker[] _mfcGapChecker = new ToleranceChecker[32];
        protected R_TRIG[] _mfcTrig = new R_TRIG[32];

        protected ToleranceChecker[] _pcGapChecker = new ToleranceChecker[7];
        protected R_TRIG[] _pcTrig = new R_TRIG[7];
        protected R_TRIG[] _pcTrig2 = new R_TRIG[7];

        protected double[] _pressurePrevious = new double[7];

        #endregion

        public Process(ModuleName module, PMModule pm1) : base(module, pm1)
        {
            Module = module.ToString();
            Name = "Process";

            _dbCallback = new RecipeDBCallback();
            _fdc = new Fdc(Module);
            _pmInterLock = DEVICE.GetDevice<IoInterLock>($"{Module}.PMInterLock");
            this._pmSicServo = DEVICE.GetDevice<SicServo>($"{Module}.PMServo");

            if (this._pmSicServo != null)
            {
                this.bAlarm = SC.GetValue<bool>($"PM.{Module}.RotationAlarm.WarningOrAlarm");
                this.fThreshold = SC.GetValue<double>($"PM.{Module}.RotationAlarm.Threshold");
                this.iTimes = SC.GetValue<int>($"PM.{Module}.RotationAlarm.Times");
            }


            for (int i = 0; i < _mfcGapChecker.Length; i++)
            {
                _mfcGapChecker[i] = new ToleranceChecker();
                _mfcTrig[i] = new R_TRIG();
            }

            for (int i = 0; i < _pcGapChecker.Length; i++)
            {
                _pcGapChecker[i] = new ToleranceChecker();
                _pcTrig[i] = new R_TRIG();
                _pcTrig2[i] = new R_TRIG();
            }


            Initialize();

            Calculte();

            SC.RegisterValueChangedCallback($"PM.{Module}.PT1PT2PressureDifferenceUpperLimit", (obj) => { _pressureDifferenceUpperLimit = (double)obj; });

            _thread = new PeriodicJob(10 * 1000, Calculte, "Calculte Standard Deviation", false);
            _threadRotationAlarm =
                new PeriodicJob(1000, CalculteRotationAlarm, "Calculte Rotation Alarm Deviation", false);
        }

        public override Result Start(params object[] param)
        {
            Reset();
            _hasRecordRunTime = false;
            if (!_pmInterLock.SetPMProcessRunning(true, out string reason))
            {
                EV.PostAlarmLog(Module, $"can not run Process, {reason}");
                return Result.FAIL;
            }

            _stepTimer = new DeviceTimer();
            _curStepElpasedTimeBeforePaused = 0;
            //_stepTimer2 = new DeviceTimer();
            //_recipeTimer = new DeviceTimer();

            //_stepTimer.Start(0);

            _lstSkipSteps = new List<int>();

            _currentStepIndex = 99;
            _currentStepNumber = CurStepTotalLoopCount = 0;
            _dummyStepCount = 0;

            _estimatedTimeCalcTimer.Start(1000);
            _rampCalcTimer.Start(1000);

            PmDevice.RecipeRunningInfo.InnerId = Guid.NewGuid();
            PmDevice.RecipeRunningInfo.BeginTime = DateTime.Now;
            PmDevice.RecipeRunningInfo.TotalTime = CalcRecipeTime();
            PmDevice.RecipeRunningInfo.IsRoutineAbort = false;

            PmDevice.RecipeRunningInfo.StepNumber = 1;
            PmDevice.RecipeRunningInfo.StepName =
                PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepName;

            _state = RecipeRunningState.ExecStep;

            _recipeTimer.Start(int.MaxValue);

            _dbCallback.RecipeStart(PmDevice.Module, 0, PmDevice.RecipeRunningInfo.InnerId.ToString(),
                PmDevice.RecipeRunningInfo.RecipeName);
            _dbCallback.RecipeUpdateStatus(PmDevice.RecipeRunningInfo.InnerId.ToString(), "InProcess");

            //手动工艺时LotID和SequenceID可能是string.Empty
            //补全路径
            string recipeID = PmDevice.RecipeRunningInfo.RecipeName + ".rcp";
            string squenceID = $"Sequence\\{PmDevice.GetWaferSequenceID()}.seq";

            GemManager.Instance.Equipment?.TriggerEvent("PMRecipeStart", new string[] { "ChamberID", "RecipeID", "LotID", "SequenceID" }, new object[] { PmDevice.Module, recipeID, PmDevice.GetWaferLotID(), squenceID });

            WaferManager.Instance.UpdateWaferProcessStatus(ModuleHelper.Converter(Module), 0,
                WaferProcessStatus.InProcess);
            WaferManager.Instance.GetWafer(ModuleHelper.Converter(Module), 0).TrayProcessCount--;

            _fdc.Reset();

            _isDryRun = SC.GetValue<bool>($"PM.{Module}.DryRun.IsDryRun");
            _delayTimeDryRun = SC.GetValue<int>($"PM.{Module}.DryRun.DryRunDelayTime");
            _tempOffset = SC.GetValue<double>($"PM.{Module}.Process.TempOffset");

            _pressureDifferenceUpperLimit = SC.GetValue<double>($"PM.{Module}.PT1PT2PressureDifferenceUpperLimit");

            ResetHeaterResCheckResult();

            _thread.Start();
            _threadRotationAlarm.Start();

            Notify($"Start");
            return Result.RUN;
        }

        #region Heater Resistance Monitor

        private readonly R_TRIG _trigHeaterResOutOfRange = new();
        private readonly R_TRIG _trigHeaterResMonitorBegin = new();
        private readonly R_TRIG _trigHeaterResMonitorEnd = new();
        private readonly R_TRIG _trigPressureDifference = new();


        private void ResetHeaterResCheckResult()
        {
            _trigHeaterResOutOfRange.RST = true;
            _trigHeaterResMonitorBegin.RST = true;
            _trigHeaterResMonitorEnd.RST = true;
            _trigPressureDifference.RST = true;
        }

        private void MonitorHeaterResistance()
        {
            var reason = "";
            var totalElapseTime = PmDevice.RecipeRunningInfo.TotalElapseTime;//Recipe已经执行的时间
            var totalTime = PmDevice.RecipeRunningInfo.TotalTime;//Recipe总时间

            if (totalElapseTime == 0) //当开始执行后再去判断时间和电阻
                return;

            // 工艺刚开始和快结束的一段时间内，不需要检测电阻值。
            var ignoredDurationSec = SC.GetValue<double>($"PM.{Module}.Heater.InProcessResistanceMonitorIgnoreDuration");

            // 开始监测和节结束监测电阻时，输出信息，方便调试。
            _trigHeaterResMonitorBegin.CLK = totalElapseTime >= ignoredDurationSec;
            _trigHeaterResMonitorEnd.CLK = totalTime - totalElapseTime < ignoredDurationSec;
            if (_trigHeaterResMonitorBegin.Q)
                Notify("Begin Heater Resistance Monitor");
            if (_trigHeaterResMonitorEnd.Q)
                Notify("End Heater Resistance Monitor");

            // 工艺刚开始和快结束的一段时间内，不需要检测电阻值。
            if (!_trigHeaterResMonitorBegin.M || _trigHeaterResMonitorEnd.M)
                return;

            // 如果在工艺中，检测Heater电阻
            for (var i = 1; i <= 3; i++) //检测出所有的加热丝是否有断开的,不要提前结束循环
            {
                var ioPsuData = (IoPsuData)DATA.Poll($"{Module}.PSU{i}.DeviceData");
                if (ioPsuData != null)
                {
                    if (ioPsuData.IsResistanceOutOfRange)//PSU加热丝断开,后续可能增加条件判断
                        reason += $"PSU{i} resistance:{ioPsuData.Resistance} is out of range\r\n ";
                }
                
                var ioScrData = (IoPsuData)DATA.Poll($"{Module}.SCR{i}.DeviceData");
                if (ioScrData != null)
                {
                    if (ioScrData.IsResistanceOutOfRange)//SCR加热丝断开,后续可能增加条件判断
                        reason += $"SCR{i} resistance:{ioScrData.Resistance} is out of range\r\n ";
                }
            }

            if (reason.Length > 0)
            {
                // 某个加热器电阻超标
                _trigHeaterResOutOfRange.CLK = true;
                if (_trigHeaterResOutOfRange.Q)
                {
                    var alarmLevel = SC.SafeGetStringValue($"PM.{Module}.Heater.InProcessResistanceFailAlarmLevel", "Alarm");
                    if (alarmLevel == "Alarm")
                        Stop(reason);
                    else
                        EV.PostWarningLog(Module,reason);
                }
            }
        }

        private void PressureDifferenceDetection()
        {
            double pt1 = PmDevice.GetChamberPressure();

            double pt2 = PmDevice.GetForelinePressure();

            double d = Math.Abs(pt1 - pt2);
            if (d >= _pressureDifferenceUpperLimit)
                _trigPressureDifference.CLK = true;

            if (_trigPressureDifference.Q)
            {
                string reason = $"PT1={pt1}  PT2={pt2},Difference {d}  over  DifferenceMax={_pressureDifferenceUpperLimit} ";
                var alarmLevel = SC.SafeGetStringValue($"PM.{Module}.PT1PT2PressureDifferenceMaxAlarmLevel", "Alarm");
                if (alarmLevel == "Alarm")
                    Stop(reason);
                else
                    EV.PostWarningLog(Module, reason);
            }
        }

        #endregion

        public override Result Monitor()
        {
            if (!PmDevice.CheckEnableRunProcess(out string reason))
            {
                EV.PostAlarmLog(Module, reason);
                return Result.FAIL;
            }

            if (_isDryRun) // 空跑工艺
            {
                try
                {
                    DryRunProcess((int)RoutineStep.WaitProcess, $"Chamber:{Name}:WaitProcess", _delayTimeDryRun);
                }
                catch (RoutineBreakException)
                {
                    return Result.RUN;
                }
                catch (RoutineFaildException)
                {
                    return Result.FAIL;
                }

                Notify("End");

                return Result.DONE;
            }
            else
            {
                MonitorRecipeEndTime();

                MonitorRecipeRunInfo();

                MonitorHeaterResistance(); //加热丝断开检测

                PressureDifferenceDetection();//腔体和管道压力检测

                lock (_recipeLocker)
                {
                    try
                    {
                        switch (_state)
                        {
                            case RecipeRunningState.ExecStep:
                            {
                                PmDevice.ResetToleranceChecker();

                                //int stepTime = (int)PMDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime * 1000;
                                if (ContinueAction != RecipeContinueMode.StepContinue)
                                {
                                    _curStepElpasedTimeBeforePaused = 0;
                                    _curStepElpasedTimeBeforePaused2 = 0;
                                }

                                ContinueAction = RecipeContinueMode.None;

                                if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].IsLoopStartStep)
                                {
                                    CurStepTotalLoopCount = PmDevice.RecipeRunningInfo
                                        .RecipeStepList[_currentStepNumber].LoopCount;
                                    if (CurStepTotalLoopCount == 0)
                                    {
                                        CurrentLoopCount = 0;
                                    }
                                    else
                                    {
                                        CurrentLoopCount++;
                                    }
                                }

                                //stepTime = (int)(PMDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime - _curStepElpasedTimeBeforePaused / 1000);
                                _stepTimer.Start(
                                    PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime * 1000 -
                                    _curStepElpasedTimeBeforePaused);

                                if (!_stepTimer2.IsIdle())
                                {
                                    _curStepElpasedTimeBeforePaused2 += _stepTimer2.GetElapseTime();
                                    _stepTimer2.Stop();
                                }

                                _stepTimer2.Start(int.MaxValue);

                                Notify($"Running step {_currentStepNumber + 1} : {PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepName}");

                                GemManager.Instance?.TriggerEvent($"{Module}RecipeStepStart", new string[] { $"{Module}.SelectedRecipeName", $"{Module}.RecipeStepNumber",$"{Module}.RecipeStepName" },
                                        new object[] { PmDevice.RecipeRunningInfo.RecipeName, _currentStepNumber + 1, 
                                        PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepName });

                                if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].IsDummyStep)
                                {
                                    _dummyStepCount++;
                                }

                                //执行工艺程序命令
                                foreach (var recipeCmd in PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                             .RecipeCommands.Keys)
                                {
                                    if (recipeCmd == "SusHeaterSetMode")
                                    {
                                        if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                .RecipeCommands[recipeCmd] == "Jump")
                                            _isPSUHeaterJumpMode = true;
                                        else
                                            _isPSUHeaterJumpMode = false;

                                        continue;
                                    }

                                    if (recipeCmd == "WWHeaterSetMode")
                                    {
                                        if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                .RecipeCommands[recipeCmd] == "Jump")
                                            _isSCRHeaterJumpMode = true;
                                        else
                                            _isSCRHeaterJumpMode = false;

                                        continue;
                                    }

                                    if (recipeCmd == "FlowSetMode")
                                    {
                                        if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                .RecipeCommands[recipeCmd] == "Jump")
                                            _isMFCJumpMode = true;
                                        else
                                            _isMFCJumpMode = false;

                                        continue;
                                    }

                                    if (IsCmdSkip(recipeCmd)) // 不是注册的方法，需要跳过
                                        continue;

                                    if (!OP.CanDoOperation($"{Module}.{recipeCmd}", out reason,
                                            PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                .RecipeCommands[recipeCmd]))
                                    {
                                        EV.PostAlarmLog(Module, $"Can not execute {recipeCmd}, {reason}");
                                        return Result.FAIL;
                                    }
                                    else
                                    {
                                        int time = (int)(PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                             .StepTime * 1000 -
                                                         _curStepElpasedTimeBeforePaused); // (int)PMDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime * 1000;

                                        if (recipeCmd.StartsWith("TC1") && _isPSUHeaterJumpMode)
                                        {
                                            time = 1;
                                        }

                                        if (recipeCmd.StartsWith("TC2") && _isSCRHeaterJumpMode)
                                        {
                                            time = 1;
                                        }

                                        if (recipeCmd.StartsWith("Mfc") && recipeCmd.EndsWith(".Ramp") &&
                                            !PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].IsDummyStep)
                                        {
                                            if (_isMFCJumpMode)
                                            {
                                                time = 1;
                                            }
                                        }

                                        if ((recipeCmd == "TV.SetPressure"
                                             || recipeCmd == "PMServo.SetActualSpeed"
                                             || recipeCmd.StartsWith("Pressure") && recipeCmd.EndsWith(".Ramp")
                                             || recipeCmd.StartsWith("Mfc") && recipeCmd.EndsWith(".Ramp"))
                                            && !PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                .IsDummyStep)
                                        {
                                            if (_currentStepNumber >= 1)
                                            {
                                                int previousStepNumber = _currentStepNumber - 1;

                                                if (PmDevice.RecipeRunningInfo.RecipeStepList[previousStepNumber]
                                                    .IsDummyStep)
                                                    previousStepNumber = _currentStepNumber - 2;

                                                if (PmDevice.RecipeRunningInfo.RecipeStepList[previousStepNumber]
                                                    .RecipeCommands.ContainsKey(recipeCmd))
                                                {
                                                    string previousValue = PmDevice.RecipeRunningInfo
                                                        .RecipeStepList[previousStepNumber].RecipeCommands[recipeCmd];
                                                    string currentValue = PmDevice.RecipeRunningInfo
                                                        .RecipeStepList[_currentStepNumber].RecipeCommands[recipeCmd];
                                                    if (previousValue == currentValue)
                                                    {
                                                        if (_lstSkipSteps.Count > 0 &&
                                                            _lstSkipSteps.Contains(
                                                                previousStepNumber)) //上一步是跳步过来的，这一步和上一步的值是相同的不用设置
                                                        {
                                                            continue;
                                                        }

                                                        time = 1;
                                                    }
                                                }
                                            }
                                        }

                                        OP.DoOperation($"{Module}.{recipeCmd}", out string reason1, time,
                                            PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                                .RecipeCommands[recipeCmd]);
                                    }
                                }

                                if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].EndBy ==
                                    EnumEndByCondition.ByTime)
                                    _state = RecipeRunningState.TimeWait;
                                else
                                    _state = RecipeRunningState.ConditionWait;

                                //ResetChecker();

                                _dbCallback.RecipeStepStart(PmDevice.RecipeRunningInfo.InnerId.ToString(),
                                    _currentStepNumber,
                                    PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepName,
                                    (float)PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime);
                                _fdc.Start(PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber]
                                    .RecipeCommands);
                            }
                                break;

                            case RecipeRunningState.TimeWait:

                                if (IsPaused)
                                {
                                    _state = RecipeRunningState.Paused;
                                }

                                if (_stepTimer.IsTimeout())
                                {
                                    _state = RecipeRunningState.StepCompleted;
                                    Grow();
                                }

                                if (PmDevice.RecipeRunningInfo.NeedReloadRecipe)
                                {
                                    if (string.IsNullOrEmpty(PmDevice.RecipeRunningInfo.XmlRecipeToReload))
                                    {
                                        EV.PostWarningLog(Module, "Recipe is required to be reloaded but no new recipe is received");
                                        PmDevice.RecipeRunningInfo.NeedReloadRecipe = false;
                                    }
                                    else
                                    {   //重新加载后面的Recipe内容
                                        if (RecipeParser.ParseXmlString(PmDevice.RecipeRunningInfo.XmlRecipeToReload, Module, out var recipeHead, out var recipeSteps, out var reason1))
                                        {
                                            //记录高亮部分
                                            foreach (var item in PmDevice.RecipeRunningInfo.HighlightDic)
                                            {
                                                var s = recipeSteps.Find(i => i.StepUid == item.Key);
                                                if (s != null)
                                                {
                                                    s.HighLightList = item.Value;
                                                }
                                            }
                                            PmDevice.RecipeRunningInfo.RecipeStepList = recipeSteps;
                                            PmDevice.RecipeRunningInfo.TotalTime = CalcRecipeTime();
                                            PmDevice.RecipeRunningInfo.NeedReloadRecipe = false;
                                        }
                                        else
                                        {
                                            EV.PostWarningLog(Module, $"Reloading Recipe failed, {reason1}");
                                        }
                                    }

                                }

                                //ToleranceChecker();

                                SkipStepForHeat();

                                break;

                            case RecipeRunningState.ConditionWait:
                            {
                                if (_stepTimer.IsTimeout())
                                {
                                    _state = RecipeRunningState.StepCompleted;
                                    Grow();
                                }
                            }
                                break;

                            case RecipeRunningState.Paused:
                                PmDevice.PauseRecipe(out reason);
                                if (!_stepTimer.IsIdle())
                                {
                                    _curStepElpasedTimeBeforePaused += _stepTimer.GetElapseTime();
                                    _stepTimer.Stop();
                                }

                                switch (ContinueAction)
                                {
                                    case RecipeContinueMode.None:
                                        break;
                                    case RecipeContinueMode.WaferReturnAndJobStop:
                                        //Singleton<RouteManager>.Instance.CheckToPostMessage((int)RouteManager.MSG.StopJob);
                                        _state = RecipeRunningState.Error;
                                        break;
                                    case RecipeContinueMode.RecipeCompleted:
                                        _state = RecipeRunningState.RecipeCompleted;
                                        break;
                                    case RecipeContinueMode.StepContinue:
                                        _state = RecipeRunningState.ExecStep;
                                        break;
                                    case RecipeContinueMode.StepRestart:
                                        _state = RecipeRunningState.ExecStep;
                                        break;
                                    case RecipeContinueMode.RecipeRestart:
                                        _currentStepNumber = 0;
                                        _state = RecipeRunningState.ExecStep;
                                        break;
                                    case RecipeContinueMode.NextStep:
                                        _state = RecipeRunningState.StepCompleted;
                                        break;
                                }

                                break;

                            case RecipeRunningState.StepCompleted:
                            {
                                    //放在前面，stepnumber后面会被更新
                                 GemManager.Instance?.TriggerEvent($"{Module}RecipeStepComplete", 
                                     new string[] { $"{Module}.SelectedRecipeName", $"{Module}.RecipeStepNumber", $"{Module}.RecipeStepName" },
                                          new object[] { PmDevice.RecipeRunningInfo.RecipeName, _currentStepNumber + 1,PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepName });

                                    _stepTimer2.Stop();

                                _dbCallback.RecipeStepEnd(PmDevice.RecipeRunningInfo.InnerId.ToString(),
                                    _currentStepNumber, _fdc.DataList);
                                _fdc.Stop();

                                if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].IsLoopEndStep)
                                {
                                    //重新读取循环的设定次数
                                    for (int nn = _currentStepNumber; nn >= 0; nn--)
                                    {
                                        if (PmDevice.RecipeRunningInfo.RecipeStepList[nn].IsLoopStartStep)
                                        {
                                            CurStepTotalLoopCount =
                                                PmDevice.RecipeRunningInfo.RecipeStepList[nn].LoopCount;
                                            break;
                                        }
                                    }

                                    if (CurrentLoopCount >= CurStepTotalLoopCount)
                                    {
                                        CurrentLoopCount = CurStepTotalLoopCount = 0;
                                        _currentStepNumber++;
                                    }
                                    else
                                    {
                                        int n = _currentStepNumber - 1;
                                        int next = -1;
                                        while (n >= 0)
                                        {
                                            if (PmDevice.RecipeRunningInfo.RecipeStepList[n].IsLoopStartStep)
                                            {
                                                next = n;
                                                break;
                                            }

                                            n--;
                                        }

                                        if (next == -1)
                                            throw new Exception("Loop End control error");
                                        _currentStepNumber = next;
                                    }
                                }
                                else
                                {
                                    _currentStepNumber++;
                                }

                                if (_currentStepNumber >= PmDevice.RecipeRunningInfo.RecipeStepList.Count)
                                {
                                    _currentStepNumber = PmDevice.RecipeRunningInfo.RecipeStepList.Count - 1;
                                    _state = RecipeRunningState.RecipeCompleted;
                                }
                                else
                                {
                                    _state = RecipeRunningState.ExecStep;
                                }
                            }


                                break;

                            case RecipeRunningState.RecipeCompleted:
                                {

                                    //更新PM的Runtime
                                    if (!_hasRecordRunTime)
                                    {
                                        _hasRecordRunTime = true;
                                        RuntimeDataRecorder.UpdateElapseTimePM(Module,
                                            (int)_recipeTimer.GetElapseTime() / 1000);
                                    }

                                    _recipeTimer.Stop();
                                    Notify("Finished");
                                    GrowCheck();

                                    //手动工艺时LotID和SequenceID可能是string.Empty
                                    //补全路径
                                    string recipeID = PmDevice.RecipeRunningInfo.RecipeName + ".rcp";
                                    string squenceID = $"Sequence\\{PmDevice.GetWaferSequenceID()}.seq";

                                    GemManager.Instance.Equipment?.TriggerEvent("PMRecipeComplete", new string[] { "ChamberID", "RecipeID", "LotID", "SequenceID" }, new object[] { PmDevice.Module, recipeID, PmDevice.GetWaferLotID(), squenceID });

                                    return Result.DONE;
                                }

                            case RecipeRunningState.Error:
                            {
                                //更新PM的Runtime
                                if (!_hasRecordRunTime)
                                {
                                    _hasRecordRunTime = true;
                                        RuntimeDataRecorder.UpdateElapseTimePM(Module,
                                            (int)_recipeTimer.GetElapseTime() / 1000);
                                }
                                GrowCheck();
                                return Result.DONE;
                            }
                            default:
                                break;
                        }
                    }
                    catch (Exception ex)
                    {
                        PmDevice.SetHeaterStopRamp();
                        PmDevice.SetMfcStopRamp(PmDevice.GetMfcListByGroupName(MfcGroupName.All));
                        PmDevice.SetRotationStopRamp();

                        LOG.Write(ex);
                        return Result.FAIL;
                    }
                }

                return Result.RUN;
            }
        }

        

        private void MonitorRecipeRunInfo()
        {
            try
            {
                PmDevice.RecipeRunningInfo.StepNumber =
                    _currentStepNumber + 1 - _dummyStepCount; //CurStepNum start from 0, ignore dummy step
                PmDevice.RecipeRunningInfo.StepName =
                    PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepName;
                PmDevice.RecipeRunningInfo.StepTime =
                    PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].StepTime;
                PmDevice.RecipeRunningInfo.GrowthRate =
                    PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].GrowthRate;
                PmDevice.RecipeRunningInfo.StepElapseTime = _stepTimer.IsIdle()
                    ? _curStepElpasedTimeBeforePaused / 1000
                    : (_stepTimer.GetElapseTime() + _curStepElpasedTimeBeforePaused) / 1000;

                PmDevice.RecipeRunningInfo.TotalElapseTime = CalcElapseRecipeTime();

                PmDevice.RecipeRunningInfo.StepElapseTime2 = _stepTimer2.IsIdle()
                    ? _curStepElpasedTimeBeforePaused2 / 1000
                    : (_stepTimer2.GetElapseTime() + _curStepElpasedTimeBeforePaused2) / 1000;
                PmDevice.RecipeRunningInfo.TotalElapseTime2 = _recipeTimer.GetElapseTime() / 1000;

                if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].RecipeCommands
                    .ContainsKey("SHArH2Switch.SetValve"))
                {
                    PmDevice.RecipeRunningInfo.ArH2Switch = PmDevice.RecipeRunningInfo
                        .RecipeStepList[_currentStepNumber].RecipeCommands["SHArH2Switch.SetValve"];
                }

                if (PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber].RecipeCommands
                    .ContainsKey("N2Dilution.SetValve"))
                {
                    PmDevice.RecipeRunningInfo.N2FlowMode = PmDevice.RecipeRunningInfo
                        .RecipeStepList[_currentStepNumber].RecipeCommands["N2Dilution.SetValve"];
                }

                if (_currentStepIndex != PmDevice.RecipeRunningInfo.StepNumber)
                {
                    Notify(
                        $"Start Recipe: Step:{PmDevice.RecipeRunningInfo.StepNumber}  Name:{PmDevice.RecipeRunningInfo.StepName} ");
                    _currentStepIndex = PmDevice.RecipeRunningInfo.StepNumber;
                }
            }
            catch (Exception ex)
            {

            }
        }

        public override void Abort()
        {
            //Abort后设置加热比列为0
            PmDevice.TC1.SetRatio(0, 0, 0);
            PmDevice.TC2.SetRatio(0, 0, 0);

            //更新PM的Runtime
            PmDevice.RecipeRunningInfo.IsRoutineAbort = true;
            if (!_hasRecordRunTime)
            {
                _hasRecordRunTime = true;
                RuntimeDataRecorder.UpdateElapseTimePM(Module,(int)_recipeTimer.GetElapseTime() / 1000);
            }

            _state = RecipeRunningState.RecipeCompleted;

            _dbCallback.RecipeFailed(PmDevice.RecipeRunningInfo.InnerId.ToString());
            _fdc.Stop();

            PmDevice.AbortRunProcess(out string reason);

            PmDevice.RecipeRunningInfo.StepName = string.Empty;
            PmDevice.RecipeRunningInfo.StepNumber = 0;
            PmDevice.RecipeRunningInfo.StepTime = 0;
            PmDevice.RecipeRunningInfo.StepElapseTime = 0;
            PmDevice.RecipeRunningInfo.TotalTime = 0;
            PmDevice.RecipeRunningInfo.TotalElapseTime = 0;

            //手动工艺时LotID和SequenceID可能是string.Empty
            //补全路径
            string recipeID = PmDevice.RecipeRunningInfo.RecipeName + ".rcp";
            string squenceID = $"Sequence\\{PmDevice.GetWaferSequenceID()}.seq";

            GemManager.Instance.Equipment?.TriggerEvent("PMRecipeAbort", new string[] { "ChamberID", "RecipeID", "LotID", "SequenceID" }, new object[] { PmDevice.Module, recipeID, PmDevice.GetWaferLotID(), squenceID });

            //PMDevice.Rf.SetPowerOnOff(false, out _);
            //PMDevice.Microwave.SetPowerOnOff(false, out _);

            //PMDevice.GasLine1.SetFlow(out _, 0, 0);
            //PMDevice.GasLine2.SetFlow(out _, 0, 0);
            //PMDevice.GasLine3.SetFlow(out _, 0, 0);
        }

        public void ExitProcess()
        {
            if (_state == RecipeRunningState.RecipeCompleted)
            {
                _dbCallback.RecipeComplete(PmDevice.RecipeRunningInfo.InnerId.ToString());
                _fdc.Stop();
            }
            else
            {
                _dbCallback.RecipeFailed(PmDevice.RecipeRunningInfo.InnerId.ToString());
                _fdc.Stop();
            }

            _thread.Stop();
        }


        public void PauseRecipe()
        {
            if (_state != RecipeRunningState.TimeWait && _state != RecipeRunningState.ConditionWait)
                return;

            if (!IsPaused)
            {
                IsPaused = true;
                _pausedState = _state;
                _state = RecipeRunningState.Paused;
            }
        }


        public void SkipCurrentRecipeStep()
        {
            if (_state == RecipeRunningState.ConditionWait || _state == RecipeRunningState.TimeWait)
            {
                _lstSkipSteps.Add(_currentStepNumber);
                _state = RecipeRunningState.StepCompleted;
            }
        }


        protected int CalcRecipeTime()
        {
            double total = 0;
            for (int i = 0; i < PmDevice.RecipeRunningInfo.RecipeStepList.Count; i++)
            {
                if (!PmDevice.RecipeRunningInfo.RecipeStepList[i].IsDummyStep) // 不统计虚拟Step的时间
                {
                    total += PmDevice.RecipeRunningInfo.RecipeStepList[i].StepTime;
                }
            }

            return (int)total;
        }

        protected double CalcElapseRecipeTime()
        {
            double total = 0;
            for (int i = 0; i < _currentStepNumber; i++)
            {
                if (!PmDevice.RecipeRunningInfo.RecipeStepList[i].IsDummyStep) // 不统计虚拟Step的时间
                {
                    total += PmDevice.RecipeRunningInfo.RecipeStepList[i].StepTime;
                }
            }

            total += PmDevice.RecipeRunningInfo.StepElapseTime;

            return total;
        }

        protected void MonitorRecipeEndTime()
        {
            try
            {
                if (!_estimatedTimeCalcTimer.IsTimeout())
                    return;
                _estimatedTimeCalcTimer.Start(1000);

                EstimatedTotalLeftTime = 0;

                if (_state == RecipeRunningState.RecipeCompleted)
                    return;

                if (!(_currentStepNumber >= 0 &&
                      _currentStepNumber <= PmDevice.RecipeRunningInfo.RecipeStepList.Count - 1))
                    return;

                if (CurStepLeftTime > 0)
                {
                    EstimatedTotalLeftTime = CurStepLeftTime;
                }

                int nextBegin = _currentStepNumber;
                bool IsInLoop = false;
                int iNum1 = 0;
                int iNum2 = 0;
                //int j=i;
                for (int j = _currentStepNumber; j < PmDevice.RecipeRunningInfo.RecipeStepList.Count; j++)
                {
                    if (PmDevice.RecipeRunningInfo.RecipeStepList[j].IsLoopEndStep)
                    {
                        iNum2 = j;
                        IsInLoop = true;
                        break;
                    }
                    else if (j > _currentStepNumber && PmDevice.RecipeRunningInfo.RecipeStepList[j].IsLoopStartStep)
                    {
                        IsInLoop = false;
                        break;
                    }
                }

                if (IsInLoop)
                {
                    iNum1 = _currentStepNumber;
                    for (int j = _currentStepNumber; j >= 0; j--)
                    {
                        if (PmDevice.RecipeRunningInfo.RecipeStepList[j].IsLoopStartStep)
                        {
                            iNum1 = j;
                            break;
                        }
                    }

                    for (int j = _currentStepNumber + 1; j <= iNum2; j++)
                    {
                        EstimatedTotalLeftTime += PmDevice.RecipeRunningInfo.RecipeStepList[j].StepTime * 1000 *
                                                  (PmDevice.RecipeRunningInfo.RecipeStepList[iNum1].LoopCount -
                                                      CurrentLoopCount + 1);
                    }

                    for (int j = iNum1; j <= _currentStepNumber; j++)
                    {
                        EstimatedTotalLeftTime += PmDevice.RecipeRunningInfo.RecipeStepList[j].StepTime * 1000 *
                                                  (PmDevice.RecipeRunningInfo.RecipeStepList[iNum1].LoopCount -
                                                   CurrentLoopCount);
                    }

                    nextBegin = iNum2 + 1;
                }
                else
                {
                    nextBegin++;
                }

                for (int j = nextBegin; j < PmDevice.RecipeRunningInfo.RecipeStepList.Count; j++)
                {
                    if (PmDevice.RecipeRunningInfo.RecipeStepList[j].IsLoopStartStep)
                    {
                        //j=i;
                        iNum1 = j;
                        iNum2 = j + 1;
                        double lr1 = 0;
                        for (int m = j; m < PmDevice.RecipeRunningInfo.RecipeStepList.Count; m++)
                        {
                            lr1 += PmDevice.RecipeRunningInfo.RecipeStepList[m].StepTime * 1000;
                            if (PmDevice.RecipeRunningInfo.RecipeStepList[m].IsLoopEndStep)
                            {
                                iNum2 = m;
                                break;
                            }
                        }

                        EstimatedTotalLeftTime += lr1 * PmDevice.RecipeRunningInfo.RecipeStepList[iNum1].LoopCount;
                        j = iNum2;
                    }
                    else
                    {
                        EstimatedTotalLeftTime += PmDevice.RecipeRunningInfo.RecipeStepList[j].StepTime * 1000;
                    }
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public void SetContinue(string continueMode)
        {
            switch (continueMode)
            {
                case "Step continue":
                    ContinueAction = RecipeContinueMode.StepContinue;
                    break;
                case "Step restart":
                    ContinueAction = RecipeContinueMode.StepRestart;
                    break;
                case "Next step":
                    ContinueAction = RecipeContinueMode.NextStep;
                    break;
                case "Recipe restart":
                    ContinueAction = RecipeContinueMode.RecipeRestart;
                    break;
                case "Recipe complete":
                    ContinueAction = RecipeContinueMode.RecipeCompleted;
                    break;
                case "Wafer return and job stop":
                    ContinueAction = RecipeContinueMode.WaferReturnAndJobStop;
                    break;
            }

            IsPaused = false;

            PmDevice.ResetToleranceChecker();
        }

        public void DryRunProcess(int id, string stepName, int delayTime)
        {
            Tuple<bool, Result> ret = Delay(id, () =>
            {
                Notify($"Dry run process {delayTime} seconds");

                _stepSpan = new TimeSpan(0, 0, 0, (int)delayTime);
                _stepStartTime = DateTime.Now;
                _stepName = stepName;

                return true;
            }, delayTime * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }

                throw new RoutineBreakException();
            }
        }

        public void ToleranceChecker()
        {
            #region MFC

            for (int i = 0; i < _mfcGapChecker.Length; i++)
            {
                _mfcGapChecker[i].Monitor(PmDevice._mfcList[i].FeedBack, PmDevice._mfcList[i].SetPoint * (1 - 2 / 100),
                    PmDevice._mfcList[i].SetPoint * (1 + 2 / 100), 5 * 60);

                if (_mfcGapChecker[i].Trig)
                {
                    EV.PostWarningLog(Module, $"{PmDevice._mfcList[i].Name} flow gap > 2%, over 5 minites");
                }
            }

            for (int i = 0; i < _mfcTrig.Length; i++)
            {
                double gap = Convert.ToDouble(dbMfcGapResults[i].StdDev);
                double setPoint = Convert.ToDouble(dbMfcSetPointResults[i].Mean);

                _mfcTrig[i].CLK = gap / setPoint > 1 / 100;

                if (_mfcTrig[i].Q)
                {
                    EV.PostWarningLog(Module,
                        $"{PmDevice._mfcList[i].Name} flow standard deviation > 1%, for 5 minites");
                }
            }

            #endregion

            #region PC

            for (int i = 0; i < _pcGapChecker.Length; i++)
            {
                _pcGapChecker[i].Monitor(PmDevice._pcList[i].FeedBack, PmDevice._pcList[i].SetPoint - 60,
                    PmDevice._pcList[i].SetPoint + 60, 5 * 60);

                if (_pcGapChecker[i].Trig)
                {
                    EV.PostWarningLog(Module, $"{PmDevice._pcList[i].Name} flow gap > 60 mbar over 5 minites");
                }
            }

            for (int i = 0; i < _pcTrig.Length; i++)
            {
                double gap = Convert.ToDouble(dbPcGapResults[i].StdDev);
                //double setPoint = Convert.ToDouble(dbPcSetPointResults[i].StdDev);

                _pcTrig[i].CLK = gap > 10;

                if (_pcTrig[i].Q)
                {
                    EV.PostWarningLog(Module,
                        $"{PmDevice._mfcList[i].Name} flow standard deviation > 1%, for 5 minites");
                }
            }

            if (_rampCalcTimer.IsTimeout())
            {
                for (int i = 0; i < _pcTrig2.Length; i++)
                {
                    _pcTrig2[i].CLK = Math.Abs(PmDevice._pcList[i].FeedBack - _pressurePrevious[i]) > 90;

                    if (_pcTrig2[i].Q)
                    {
                        EV.PostWarningLog(Module, $"{PmDevice._mfcList[i].Name} pressure ramp > 90 mbar");
                    }

                    _pressurePrevious[i] = PmDevice._pcList[i].FeedBack;
                }

                _rampCalcTimer.Start(1000);
            }

            #endregion

        }

        public void ResetChecker()
        {
            #region MFC

            for (int i = 0; i < _mfcGapChecker.Length; i++)
            {
                _mfcGapChecker[i].Reset(5 * 60);
            }

            for (int i = 0; i < _mfcTrig.Length; i++)
            {
                _mfcTrig[i].RST = true;
            }

            #endregion

            #region PC

            for (int i = 0; i < _pcGapChecker.Length; i++)
            {
                _pcGapChecker[i].Reset(5 * 60);
            }

            for (int i = 0; i < _pcTrig.Length; i++)
            {
                _pcTrig[i].RST = true;
            }

            #endregion
        }

        public void SkipStepForHeat()
        {
            int stepCount = PmDevice.RecipeRunningInfo.RecipeStepList.Count;

            if (_currentStepNumber + 1 < stepCount)
            {
                var currentStep = PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber];
                var nextStep = PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber + 1];

                if (currentStep.IsDummyStep)
                    return;

                if (nextStep.IsDummyStep)
                    nextStep = PmDevice.RecipeRunningInfo.RecipeStepList[_currentStepNumber + 2];

                if (!currentStep.RecipeCommands.ContainsKey("TC1.SetHeaterMode") ||
                    !nextStep.RecipeCommands.ContainsKey("TC1.SetHeaterMode"))
                    return;

                var currentPSUMode = (HeatStrategy)Enum.Parse(typeof(HeatStrategy),
                    currentStep.RecipeCommands["TC1.SetHeaterMode"]);
                var nextPSUMode = (HeatStrategy)Enum.Parse(typeof(HeatStrategy),
                    nextStep.RecipeCommands["TC1.SetHeaterMode"]);

                if (currentPSUMode == HeatStrategy.Power && nextPSUMode != HeatStrategy.Power)
                {
                    float PSUL2InputTemp =
                        (float)DATA.Poll(
                            $"{Module}.TC1.L2InputTempSetPoint"); // (float)DATA.Poll($"{Module}.TC1.L1PVFeedBack"); 测试用

                    float nextL2Temp = Convert.ToSingle(nextStep.RecipeCommands["TC1.SetL2TargetSP"]);

                    if (nextL2Temp > PSUL2InputTemp && nextL2Temp - PSUL2InputTemp < Math.Abs(_tempOffset))
                    {
                        SkipCurrentRecipeStep();

                        EV.PostInfoLog(Module,
                            $"Current PSU middle temperature is {PSUL2InputTemp}℃ and Power mode, next step PSU middle temperature setpoint is {nextL2Temp}℃ and {nextPSUMode} mode." +
                            $" TempOffset is {_tempOffset}℃. Need jump step!");

                    }
                }
            }
        }

        public void Grow()
        {
            try
            {
                var wi = WaferManager.Instance.GetWafer(ModuleHelper.Converter(Module), 0);
                OP.DoOperation($"HistoryCoatingManager.Grow",
                    new object[] {
                (wi.TrayInnerID).ToString(),
                PmDevice.RecipeRunningInfo.GrowthRate,
                PmDevice.RecipeRunningInfo.StepTime ,
                Module });
            }
            catch (Exception ex)
            {

                LOG.Error(ex.Message, ex);
            }
            
        }
        public void GrowCheck()
        {
            try
            {
                var wi = WaferManager.Instance.GetWafer(ModuleHelper.Converter(Module), 0);
                OP.DoOperation($"HistoryCoatingManager.GrowCheck",
                    new object[] {
                (wi.WaferInnerID).ToString(),
                Module });
            }
            catch (Exception ex)
            {

                LOG.Error(ex.Message, ex);
            }

        }
    }
}