using System;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Devices;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Mainframe.LLs;
using Mainframe.UnLoads;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadLocks;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Servo.NAIS;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.TMs;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UnLoad;

namespace Mainframe.TMs
{
    public class TMSlitValveRoutine : TMBaseRoutine
    {
        enum RoutineStep
        {
            ChamberBalance,
            OpenTMToLLVent,
            OpenTMToPMV70,
            CheckPressureCondition,

            SetSlitValve,

            SetSlowVentValve,
            SetM40,

            LLRoutine,

            Delay, 
            Delay1, Delay2, Delay3, Delay4,
            CloseTMToLLVent, 
            CloseTMToPMV70,
            PumpDownToBase,
            CheckConfinementIsDown,

            SetConfinementRingUp,
            SetConfinementRingDown,
            SetPostTransfer,
            SetPmPreTrasfer,
            SetV77,
            SetV77Close,
            SetTmMfc,

            WaitTempBelow900,
            WaitPVTempBelowSet,
            WaitPMIdle
        }


        private int _timeout;

        private SicTM _tm;
        private LoadLock _ll;
        private UnLoad _unLoad;
        private IoValve PMToTm_V70;
        private IoPressure _pmPT1;
        private IoConfinementRing _confinementRing;
        private SicServo _sicServo;
        private IoInterLock _pmIoInterLock;
        private IoTC _tc1;

        private string _paramTarget;
        private bool _paramIsOpen;
        private bool _confinementIsDown = false;


        //private TMPumpWithTurboRoutine _pumpDownRoutine;

        private TMPressureBalanceRoutine _balanceRoutine;
        private TMPressureBalancePidRoutine _pidBalanceRoutine;
        private TMPressureBalancePidRoutine _pidAwaysRoutine;
        private LoadLockServoToRoutine _llVentTo;
        private UnLoadServoToRoutine _unLoadVentTo;
        private IoMFC _m40;

        private bool _needPressureBalance;
        private bool _userPidBalance;

        private int _rotationStopTimeout = 120;

        private double _maxPressureDiffOpenSlitValve;
        private bool _isAtmMode;
        private bool _isLockLock;
        private bool _isUnLoad;
        private bool _isPM;
        private bool _isBuffer;
        private int _tmV77DelayTime = 5;
        private double _tmMfcFlow = 10;

        private bool _pmPostTrasferNeedEnableHeat = true; 
        private bool _preTransferPSUEnable = false;
        private bool _preTransferSCREnable = false;
        public IoPSU PSU1 = null;
        public IoPSU PSU2 = null;
        public IoPSU PSU3 = null;
        public IoSCR SCR1 = null;
        public IoSCR SCR2 = null;
        public IoSCR SCR3 = null;

        private double _pmPVInnerTempLimit = 0;
        private double _pmPVMiddleTempLimit = 0;
        private double _pmPVOuterTempLimit = 0;

        public TMSlitValveRoutine()
        {
            Module = ModuleName.TM.ToString();
            Name = "Slit Valve";
            _tm = DEVICE.GetDevice<SicTM>($"{ ModuleName.System.ToString()}.{ ModuleName.TM.ToString()}");
            _ll = DEVICE.GetDevice<SicLoadLock>($"{ModuleName.LoadLock}.{ModuleName.LoadLock}");
            _unLoad= DEVICE.GetDevice<SicUnLoad>($"{ModuleName.UnLoad}.{ModuleName.UnLoad}");
        }

        public void Init(string module, bool isOpen, bool needEnableHeat)
        {
            _pmPostTrasferNeedEnableHeat = needEnableHeat;
            Init(module, isOpen);
        }

        public void Init(string module, bool isOpen)
        {
            _paramTarget = module;
            _paramIsOpen = isOpen;
            Name = isOpen ? "Open Slit Valve" : "Close Slit Valve";

            _balanceRoutine = new TMPressureBalanceRoutine();
            _pidBalanceRoutine = new TMPressureBalancePidRoutine();
            _pidAwaysRoutine = new TMPressureBalancePidRoutine();
            _llVentTo = new LoadLockServoToRoutine(ModuleName.LoadLock);
            _unLoadVentTo = new UnLoadServoToRoutine(ModuleName.UnLoad);
            _balanceRoutine.Init(ModuleHelper.Converter(module));
            _pidBalanceRoutine.Init(ModuleHelper.Converter(module));
            _pidAwaysRoutine.Init(ModuleHelper.Converter(module), true);

            _needPressureBalance = SC.GetValue<bool>("TM.NeedPressureBalance");
            _userPidBalance= SC.GetValue<bool>("TM.PressureBalanceUsePid");            
        }

        public override Result Start(params object[] objs)
        {
            Reset();

            _isLockLock = ModuleHelper.IsLoadLock(_paramTarget);
            _isUnLoad = _paramTarget == ModuleName.UnLoad.ToString();
            _isPM = ModuleHelper.IsPm(_paramTarget);
            _isBuffer = _paramTarget == ModuleName.Buffer.ToString();

            if (_isPM)
            {
                PMToTm_V70 = DEVICE.GetDevice<IoValve>($"{_paramTarget}.V70");
                _confinementRing = DEVICE.GetDevice<IoConfinementRing>($"{_paramTarget}.ConfinementRing");
                _sicServo = DEVICE.GetDevice<SicServo>($"{_paramTarget}.PMServo");
                _pmIoInterLock = DEVICE.GetDevice<IoInterLock>($"{_paramTarget}.PMInterLock");
                _tc1 = DEVICE.GetDevice<IoTC>($"{_paramTarget}.TC1");
            }

            if (TMDevice.GetSlitValve(ModuleHelper.Converter(_paramTarget)) == null)
            {
                EV.PostWarningLog(Module, $"do not find slit valve info");
                return Result.FAIL;
            }

            if ((_paramIsOpen && TMDevice.CheckSlitValveOpen(ModuleHelper.Converter(_paramTarget)))
                || (!_paramIsOpen && TMDevice.CheckSlitValveClose(ModuleHelper.Converter(_paramTarget))))
            {
                string message = _paramIsOpen ? "open" : "close";                
                return Result.DONE;
            }

            _tm.CloseAllVentPumpValue();

            if (_paramIsOpen)
            {
                bool isAtmMode = SC.GetValue<bool>("System.IsATMMode");
                if (ModuleHelper.IsLoadLock(_paramTarget))
                {
                    LoadLock ll = DEVICE.GetDevice<LoadLock>($"{_paramTarget}.{_paramTarget}");

                    if (isAtmMode)
                    {
                        if (!ll.CheckAtm())
                        {
                            EV.PostWarningLog(Module, $"can not open slit valve, running in ATM mode, but {_paramTarget} not in ATM");
                            return Result.FAIL;
                        }
                    }
                    else
                    {
                        if (!ll.CheckVacuum())
                        {
                            EV.PostWarningLog(Module, $"can not open slit valve, {_paramTarget} not in vacuum");
                            return Result.FAIL;
                        }
                    }
                }

                if (ModuleHelper.IsPm(_paramTarget))
                {
                    _pmPT1 = DEVICE.GetDevice<IoPressure>($"{_paramTarget}.PT1");
                    double atmBase = SC.GetValue<double>($"PM.AtmPressureBase");
                    double vacBase = SC.GetValue<double>($"PM.VacuumPressureBase");

                    PSU1 = DEVICE.GetDevice<IoPSU>($"{_paramTarget}.PSU1");
                    PSU2 = DEVICE.GetDevice<IoPSU>($"{_paramTarget}.PSU2");
                    PSU3 = DEVICE.GetDevice<IoPSU>($"{_paramTarget}.PSU3");
                    SCR1 = DEVICE.GetDevice<IoSCR>($"{_paramTarget}.SCR1");
                    SCR2 = DEVICE.GetDevice<IoSCR>($"{_paramTarget}.SCR2");
                    SCR3 = DEVICE.GetDevice<IoSCR>($"{_paramTarget}.SCR3");

                    if (WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_paramTarget), 0))
                    {
                        _pmPVInnerTempLimit = SC.GetValue<double>($"PM.{_paramTarget}.Heater.PickPVInnerTempLimit");
                        _pmPVMiddleTempLimit = SC.GetValue<double>($"PM.{_paramTarget}.Heater.PickPVMiddleTempLimit");
                        _pmPVOuterTempLimit = SC.GetValue<double>($"PM.{_paramTarget}.Heater.PickPVOuterTempLimit");
                    }
                    else
                    {
                        _pmPVInnerTempLimit = SC.GetValue<double>($"PM.{_paramTarget}.Heater.PlacePVInnerTempLimit");
                        _pmPVMiddleTempLimit = SC.GetValue<double>($"PM.{_paramTarget}.Heater.PlacePVMiddleTempLimit");
                        _pmPVOuterTempLimit = SC.GetValue<double>($"PM.{_paramTarget}.Heater.PlacePVOuterTempLimit");
                    }

                    if (isAtmMode)
                    {
                        if (_pmPT1.FeedBack < atmBase)
                        {
                            EV.PostWarningLog(Module, $"can not open slit valve, running in ATM mode, but {_paramTarget} not in ATM");
                            return Result.FAIL;
                        }
                    }
                    else
                    {
                        if (_pmPT1.FeedBack > vacBase)
                        {
                            EV.PostWarningLog(Module, $"can not open slit valve, {_paramTarget} not in vacuum");
                            return Result.FAIL;
                        }
                    }
                }

                ModuleName[] slitValveModules = new ModuleName[]
                {
                        ModuleName.LoadLock,ModuleName.PM1,ModuleName.PM2
                };
                foreach (var slitValveModule in slitValveModules)
                {
                    if (slitValveModule.ToString() == _paramTarget)
                        continue;

                    if (!_tm.CheckSlitValveClose(slitValveModule))
                    {
                        EV.PostWarningLog(Module, $"can not open slit valve {_paramTarget},  {slitValveModule} slit valve not closed, can not open at same time");
                        return Result.FAIL;
                    }
                }
            }

            if (ModuleHelper.IsPm(_paramTarget))
            {
                _preTransferPSUEnable = SC.GetValue<bool>($"PM.{_paramTarget}.PreTransferPSUEnable");
                _preTransferSCREnable = SC.GetValue<bool>($"PM.{_paramTarget}.PreTransferSCREnable");
            }

            _maxPressureDiffOpenSlitValve = SC.GetValue<double>("TM.MaxPressureDiffOpenSlitValve");
            _timeout = SC.GetValue<int>("System.SlitValveMotionTimeout");
            _isAtmMode = SC.GetValue<bool>("System.IsATMMode");

         
            _tmV77DelayTime= SC.GetValue<int>($"TM.OpenSlitValveDelayTimeForPM");
            _tmMfcFlow = SC.GetValue<double>($"TM.MFCFlowWhenV77Open");

            Notify("Start");

            return Result.RUN;
        }


        public override Result Monitor()
        {
            try
            {
                if (_isLockLock)
                {
                    if (_paramIsOpen)
                    {
                        TimeDelay((int)RoutineStep.Delay1, 1);
                        if (_userPidBalance)
                        {
                            ExecuteRoutine((int)RoutineStep.ChamberBalance, _pidBalanceRoutine);
                        }
                        else
                        {
                            ExecuteRoutine((int)RoutineStep.ChamberBalance, _balanceRoutine);
                        }

                        if (_needPressureBalance && !_isAtmMode)
                        {
                            TimeDelay((int)RoutineStep.Delay2, 1);
                            ExecuteRoutine((int)RoutineStep.LLRoutine, _llVentTo);
                            SetTmToLoadLockVent((int)RoutineStep.OpenTMToLLVent, true, _tm, _paramTarget, 5);
                        }

                        TimeDelay((int)RoutineStep.Delay3, 1);
                        CheckPressureCondition((int)RoutineStep.CheckPressureCondition, _tm, _paramTarget);
                    }
                    SetSlitValve((int)RoutineStep.SetSlitValve, TMDevice, _paramTarget, _paramIsOpen, _timeout);
                    TimeDelay((int)RoutineStep.Delay4, 1);
                    SetTmToLoadLockVent((int)RoutineStep.CloseTMToLLVent, false, _tm, _paramTarget, 5);
                }
                else if (_isUnLoad)
                {
                    if (_paramIsOpen)
                    {
                        TimeDelay((int)RoutineStep.Delay1, 1);
                        if (_userPidBalance)
                        {
                            ExecuteRoutine((int)RoutineStep.ChamberBalance, _pidBalanceRoutine);
                        }
                        else
                        {
                            ExecuteRoutine((int)RoutineStep.ChamberBalance, _balanceRoutine);
                        }

                        if (_needPressureBalance && !_isAtmMode)
                        {
                            TimeDelay((int)RoutineStep.Delay2, 1);
                            ExecuteRoutine((int)RoutineStep.LLRoutine, _unLoadVentTo);
                            SetTmToUnLoadVent((int)RoutineStep.OpenTMToLLVent, true, _tm, _paramTarget, 10);
                        }

                        TimeDelay((int)RoutineStep.Delay3, 1);
                        CheckPressureCondition((int)RoutineStep.CheckPressureCondition, _tm, _paramTarget);
                    }
                    SetSlitValve((int)RoutineStep.SetSlitValve, TMDevice, _paramTarget, _paramIsOpen, _timeout);
                    TimeDelay((int)RoutineStep.Delay4, 1);
                    SetTmToUnLoadVent((int)RoutineStep.CloseTMToLLVent, false, _tm, _paramTarget, 10);
                }
                else if (_isPM)
                {
                    if (_paramIsOpen)
                    {
                        SetPreTransfer((int)RoutineStep.SetPmPreTrasfer, _rotationStopTimeout);//旋转停止,加热停止

                        WaitPVTempratureBelowSet((int)RoutineStep.WaitPVTempBelowSet, 600);

                        if (_needPressureBalance && !_isAtmMode)
                        {
                            if (_userPidBalance)
                            {
                                ExecuteRoutine((int)RoutineStep.ChamberBalance, _pidBalanceRoutine);
                            }
                            else
                            {
                                ExecuteRoutine((int)RoutineStep.ChamberBalance, _balanceRoutine);
                            }

                            SetTmMfc((int)RoutineStep.SetTmMfc, _tmMfcFlow);
                            SetPmToTmV70((int)RoutineStep.OpenTMToPMV70, true, _tm, _paramTarget, 5);
                            SetSlowVentValve((int)RoutineStep.SetV77, _tm, _paramIsOpen, _timeout);
                            TimeDelay((int)RoutineStep.Delay1, _tmV77DelayTime); //5秒可配置
                        }
                        CheckPressureCondition((int)RoutineStep.CheckPressureCondition, _tm, _paramTarget);
                    }


                    SetSlitValve((int)RoutineStep.SetSlitValve, TMDevice, _paramTarget, _paramIsOpen, _timeout);
                    if (!_paramIsOpen)
                    {
                        //关闭闸板阀需要关闭V77
                        SetSlowVentValve((int)RoutineStep.SetV77Close, _tm, _paramIsOpen, _timeout);
                    }
                    SetPmToTmV70((int)RoutineStep.CloseTMToPMV70, false, _tm, _paramTarget, 5);

                    if (_paramIsOpen)
                    {
                        WaitPMIdle((int)RoutineStep.WaitPMIdle, _paramTarget, 20);
                        SetConfinementRingDownAndWait((int)RoutineStep.SetConfinementRingDown, 30); //隔热罩下降
                    }

                    if (!_paramIsOpen)
                    {
                        SetPostTransfer((int)RoutineStep.SetPostTransfer, _pmPostTrasferNeedEnableHeat);
                        TimeDelay((int)RoutineStep.Delay4, 2);
                    }
                }
                else if(_isBuffer)
                {
                    //CheckPressureCondition((int)RoutineStep.CheckPressureCondition, _tm, _paramTarget);
                    SetSlitValve((int)RoutineStep.SetSlitValve, TMDevice, _paramTarget, _paramIsOpen, _timeout);
                }

            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                return Result.FAIL;
            }


            Notify("Finished");

            return Result.DONE;
        }

        public override void Abort()
        {
            _tm.CloseAllVentPumpValue();
        }

        /// <summary>
        /// 打开或关闭V85
        /// </summary>
        /// <param name="id"></param>
        /// <param name="isOpen"></param>
        /// <param name="timeDelay"></param>
        private void SetTmToLoadLockVent(int id,bool isOpen, TM tm, string module, int timeDelay)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify((isOpen ? "Open" : "Close") + " TM to LoadLock Vent");

                if (!_tm.SetTmToLLVent(isOpen, out string reason))
                {
                    Stop(reason);
                    return false;
                }

                return true;
            }, () =>
            {
                double tmPressure = tm.ChamberPressure;
                double targetPressure = 0.0;
                if (ModuleHelper.IsLoadLock(_paramTarget))
                {
                    targetPressure = _ll.ChamberPressure;
                }
                else
                {
                    Stop($"{module} not define pressure condition");
                    return false;
                }

                return Math.Abs(tmPressure - targetPressure) <= _maxPressureDiffOpenSlitValve;
            },
            timeDelay * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"can not complete in {timeDelay} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        private void SetTmToUnLoadVent(int id, bool isOpen, TM tm, string module, int timeDelay)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify((isOpen ? "Open" : "Close") + " TM to UnLoad Vent");

                if (!_tm.SetTmToUnLoadVent(isOpen, out string reason))
                {
                    Stop(reason);
                    return false;
                }

                return true;
            }, () =>
            {
                double tmPressure = tm.ChamberPressure;
                double targetPressure = _unLoad.ChamberPressure; 

                return Math.Abs(tmPressure - targetPressure) <= _maxPressureDiffOpenSlitValve;
            },
            timeDelay * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"can not complete in {timeDelay} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        public void SetPmToTmV70(int id, bool isOpen, TM tm, string module, int timeDelay)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"set V70 " + (isOpen ? "Open" : "Close"));

                if (!PMToTm_V70.TurnValve(isOpen, out string reason))
                {
                    Stop(reason);
                    return false;
                }

                return true;
            }, () =>
            {
                double tmPressure = tm.ChamberPressure;
                double targetPressure = 0.0;

                 if (ModuleHelper.IsPm(_paramTarget))
                {
                    targetPressure = DEVICE.GetDevice<IoPressure>($"{module}.PT1").FeedBack;
                }
                else
                {
                    Stop($"{module} not define pressure condition");
                    return false;
                }

                return Math.Abs(tmPressure - targetPressure) <= _maxPressureDiffOpenSlitValve;
            },
            timeDelay * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"can not complete in {timeDelay} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        public void SetSlitValve(int id, TM tm, string module, bool isOpen, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"set slit valve {module} " + (isOpen ? "Open" : "Close"));

                if (!tm.SetSlitValve(ModuleHelper.Converter(module), isOpen, out string reason))
                {
                    Stop(reason);
                    return false;
                }

                return true;
            }, () =>
            {
                return isOpen ? tm.CheckSlitValveOpen(ModuleHelper.Converter(module)) : tm.CheckSlitValveClose(ModuleHelper.Converter(module));

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"can not complete in {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        public void CheckPressureCondition(int id, TM tm, string target)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
                {
                    Notify($"check pressure condition to open {target} slit valve");

                    double tmPressure = tm.ChamberPressure;
                    double targetPressure = 0.0;
                    if (ModuleHelper.IsLoadLock(_paramTarget))
                    {
                        targetPressure = _ll.ChamberPressure;
                    }
                    else if(_paramTarget == ModuleName.UnLoad.ToString())
                    {
                        targetPressure = _unLoad.ChamberPressure;
                    }
                    else if (ModuleHelper.IsPm(_paramTarget))
                    {
                        targetPressure = DEVICE.GetDevice<IoPressure>($"{target}.PT1").FeedBack;
                    }
                    else if (_paramTarget == ModuleName.Buffer.ToString())
                    {
                        targetPressure = tm.ChamberPressure;
                    }
                    else
                    {
                        Stop($"{target} not define pressure condition");
                        return false;
                    }

                    double pressureDiff = Math.Abs(tmPressure - targetPressure);
                    if (pressureDiff > _maxPressureDiffOpenSlitValve)
                    {
                        Stop($"pressure difference {pressureDiff:F3}  between TM and {target} exceed tolerance {_maxPressureDiffOpenSlitValve}");
                        return false;
                    }

                    return true;
                });

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

        public void SetSlowVentValve(int id, SicTM tm, bool isOpen, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                string op = isOpen ? "Open" : "Close";

                Notify($"{op} Slow Vent Valve");

                if (!tm.SetSlowVentValve(isOpen, out string reason))
                {
                    Stop(reason);
                    return false;
                }

                return true;
            }, () =>
            {
                return tm.CheckSlowVentValve(isOpen);

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"Set Slow Vent Valve timeout, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        public void SetTmMfc(int id, double flow)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify($"Set TM MFC flow to {flow} ");

                _tm.SetVentMfc(flow, out string reason);

                return true;
            });

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

        public void SetConfinementRingUp(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Set Confinement RingUp");

                _confinementRing.MoveUpPos(out string reason);

                return true;
            }, () =>
            {
                 return _confinementRing.RingDone && _confinementRing.RingUpSensor;

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"Set Confinement RingUp timeout, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        public void WaitPMIdle(int id, string _targetModule, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                return true;
            }, () =>
            {
                string pm1Status = DATA.Poll($"{_targetModule}.Status") == null ? "" : DATA.Poll($"{_targetModule}.Status").ToString();
                return pm1Status == "ProcessIdle" || pm1Status == "Idle";

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"Wait PM Idle timeout, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }


        protected void SetConfinementRingDownAndWait(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Set ConfinementRing Down");

                if (!_confinementRing.MoveDownPos(out string reason))
                {
                    Stop(reason);
                    return false;
                }
                return true;
            }, () =>
            {
                return _confinementRing.RingDone && _confinementRing.RingDownSensor;
            },
             timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT)
                {
                    Stop($"Set ConfinementRing Down, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }


        public void SetPostTransfer(int id, bool postTransferEnableHeat)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify($"Set PostTransfer");

                OP.DoOperation($"{_paramTarget}.PostTransfer", new object[] { postTransferEnableHeat });

                return true;
            });

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

        public void SetPreTransfer(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Set PSU and SCR Disable");

                if (_sicServo != null)
                {
                    _sicServo.SetActualSpeed(0, 0);
                }
                if (!_preTransferPSUEnable)
                {
                    PSU1.SetPSUEnable(false, out _);
                    PSU2.SetPSUEnable(false, out _);
                    PSU3.SetPSUEnable(false, out _);
                }
                if (!_preTransferSCREnable)
                {
                    SCR1.SetEnable(false, out _);
                    SCR2.SetEnable(false, out _);
                    SCR3.SetEnable(false, out _);
                }
                return true;
            }, () =>
            {
                if (_sicServo.ActualSpeedFeedback > 0)
                {
                    return false;
                }
                if (!_preTransferPSUEnable)
                {
                    if (PSU1 != null && PSU1.StatusFeedBack)
                    {
                        return false;
                    }
                    if (PSU2 != null && PSU2.StatusFeedBack)
                    {
                        return false;
                    }
                    if (PSU3 != null && PSU3.StatusFeedBack)
                    {
                        return false;
                    }
                }
                if (!_preTransferSCREnable)
                {
                    if (SCR1 != null && SCR1.StatusFeedBack)
                    {
                        return false;
                    }
                    if (SCR2 != null && SCR2.StatusFeedBack)
                    {
                        return false;
                    }
                    if (SCR3 != null && SCR3.StatusFeedBack)
                    {
                        return false;
                    }
                }
                return true;

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"Set PreTransfer timeout, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }


        private void WaitTempratureBelow900(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Wait DiHeaterTempBelow900CSW");
                return true;

            }, () =>
            {
                if (_pmIoInterLock != null)
                {
                    return _pmIoInterLock.DiHeaterTempBelow900CSW;
                }
                else
                {
                    return true;
                }
            },
            timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT)
                {
                    Stop($"Wait PM Temprature below 900 timeout, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        private void WaitPVTempratureBelowSet(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, ()=>
            {
                Notify($"Wait PV2Temp below{_pmPVMiddleTempLimit}℃ and PV3Temp below{_pmPVOuterTempLimit}℃");
                return true;

            }, () =>
            {
                if (_tc1 != null  && _pmPVMiddleTempLimit > 0 && _pmPVOuterTempLimit > 0)
                {
                    return  _tc1.L2PVFeedBack < _pmPVMiddleTempLimit && _tc1.L3PVFeedBack < _pmPVOuterTempLimit;
                }
                else
                {
                    return true;
                }
            },
            timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT)
                {
                    Stop($"Wait PM Temprature below 900 timeout, over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }
    }


}