using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Venus_RT.Devices;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Equipment;
using Venus_Core;
using System.Threading;
using Aitex.Core.RT.Log;

namespace Venus_RT.Modules.TM
{
    class MFPumpRoutine : ModuleRoutineBase, IRoutine
    {
        private enum PumpStep
        {
            kWaitPeerModule,
            kSoftPump,
            kFastPump,
            kClosePumpValves,
            kDelayForSwitchPump,
            kSwitchLLPump
        }

        private double _pumpBasePressure;
        private double _pumpCrossingPressure;
        private int _pumpingTimeout;
        private int _switchLLPumpDelay;
        private readonly JetTM _JetTM;
        private int _forelinePressure = 200;
        //private bool _pumpIsRunning;
        private bool _skipRepeatPump = false;
        public MFPumpRoutine(JetTM jetTM, ModuleName mod) : base(mod)
        {
            _JetTM = jetTM;
            Name = "Pump Down";
        }

        public RState Start(params object[] objs)
        {
            _JetTM.TurnVentValve(Module, false);
            _JetTM.TurnPurgeValve(Module, false);

            if (_JetTM.CheckLidClosed(Module) && 
                _JetTM.CheckVentValveClosed(Module) && 
                _JetTM.CheckPurgeValveClosed(Module))
            {
                Reset();
                _pumpBasePressure = SC.GetValue<double>($"{Module}.PumpBasePressure");
                _pumpCrossingPressure = SC.GetValue<double>($"{Module}.PumpCrossingPressure");
                _pumpingTimeout = SC.GetValue<int>($"{Module}.PumpingTimeout") * 1000;
                if (Module == ModuleName.LLA || Module == ModuleName.LLB)
                    _switchLLPumpDelay = SC.GetValue<int>($"{Module}.SwitchLLPumpDelay");
                else
                    _switchLLPumpDelay = 0;

                _skipRepeatPump = false;
                if (ModuleHelper.IsLoadLock(Module) && IsPressureReady())
                    _skipRepeatPump = true;

                //前端压力值高于某个数值
                _forelinePressure = SC.GetValue<int>($"{Module}.PumpForelinePressureLimit");

                if (_JetTM.CheckPumpIsRunning(Module)==false || _JetTM.GetModuleForelinePressure(Module) > _forelinePressure)
                {
                    LOG.Write(eEvent.ERR_TM, Module, $"Cannot start pumpdown, drypump running:{_JetTM.CheckPumpIsRunning(Module)}, ForelinePressure:{_JetTM.GetModuleForelinePressure(Module)}=>Target:{_forelinePressure}");
                    return RState.Failed;
                }

                return Runner.Start(Module, Name);
            }

            return RState.Failed;
        }

        public RState Monitor()
        {
            if (_skipRepeatPump)
            {
                Notify($" pressure: {_JetTM.GetModulePressure(Module)} is ready, skip the the pumping routine.");
                ClosePumpValves();
                return RState.End;
            }
                

            Runner.Wait(PumpStep.kWaitPeerModule,      WaitPeerModule,                                                                                             _delay_60s)
                .Run(PumpStep.kSoftPump,               OpenSoftPump,           () => { return _JetTM.GetModulePressure(Module) < _pumpCrossingPressure; },         _pumpingTimeout)
                .Run(PumpStep.kFastPump,               SwitchFastPump,         IsPressureReady,                                                                    _pumpingTimeout)
                .Run(PumpStep.kClosePumpValves,        ClosePumpValves,        NullFun)
                .Delay(PumpStep.kDelayForSwitchPump,                                                                                                               _switchLLPumpDelay)
                .End(PumpStep.kSwitchLLPump,           ReleaseLLPump,          NullFun);

            return Runner.Status;
        }

        private bool WaitPeerModule()
        {
            if (!IsPressureReady() && IsLLModule())
            {
                //return _JetTM.TryGetLLPump(Module);
                return true;
            }

            return true;
        }

        private bool IsLLModule()
        {
            return Module == ModuleName.LLA || Module == ModuleName.LLB;
        }

        private bool IsPressureReady()
        {
            return _JetTM.GetModulePressure(Module) < _pumpBasePressure;
        }

        private bool OpenSoftPump()
        {
            if (!IsPressureReady())
            {
                _JetTM.TurnSoftPumpValve(Module, true);
            }

            return true;
        }

        private bool SwitchFastPump()
        {
            if (_JetTM.GetModulePressure(Module) > (_pumpBasePressure-5))
            {
                _JetTM.TurnSoftPumpValve(Module, false);
                _JetTM.TurnFastPumpValve(Module, true);
            }

            return true;
        }
        private bool ClosePumpValves()
        {
            _JetTM.TurnSoftPumpValve(Module, false);
            _JetTM.TurnFastPumpValve(Module, false);

            return true;
        }

        private bool ReleaseLLPump()
        {
            if (Module == ModuleName.LLA || Module == ModuleName.LLB)
                _JetTM.ReleasePump(Module);
            return true;
        }

        public void Abort()
        {
            ClosePumpValves();
        }
    }
}