using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.Core.Equipments;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Venus_Core;
using Venus_RT.Devices;
using Venus_RT.Devices.TM;
using Venus_RT.Devices.VCE;
using Venus_RT.Modules.TM.VenusEntity;

namespace Venus_RT.Modules.VCE
{
    public class LoadPrepareRoutine : ModuleRoutineBase, IRoutine
    {
        private enum LoadPrepareStep
        {
            VceVent,
            VceGotoLP,
            VceOuterDoorOpen,
            NotifyDone
        }
        
        private VCEModuleBase _vce;//动作驱动
        private int _vcetimeout;
        private SEMFVentRoutine _ventroutine;
        private bool needvent = false;
        public LoadPrepareRoutine(ModuleName module, VCEModuleBase vce, TMBase tm) : base(module)
        {
            Module = module;
            _vce = vce;
            _ventroutine = new SEMFVentRoutine(tm, module);
        }

        public RState Start(params object[] objs)
        {
            //如果不是ATM 不允许执行
            if (!Singleton<RouteManager>.Instance.seTM.VCEIsATM(Module))
            {
                needvent = true;
            }
            else
                needvent = false;

            _vcetimeout = SC.GetValue<int>($"{Module}.MotionTimeout") * 1000;
            Reset();
            return Runner.Start(Module, $"Load Prepare");
        }

        public RState Monitor()
        {
            Runner.Run(LoadPrepareStep.VceVent,             VceVent,            VCEIsATM)
                .Run(LoadPrepareStep.VceGotoLP,           VceGotoLP,          CheckVceStageDownDone , _vcetimeout)
                .Run(LoadPrepareStep.VceOuterDoorOpen,      VceOuterDoorOpen,   CheckVceOuterDoorOpenDone, _vcetimeout)
                .End(LoadPrepareStep.NotifyDone,            NullFun,            100);
            return Runner.Status;
        }

        private bool VceVent()
        {
            if (Singleton<RouteManager>.Instance.seTM.VCEIsATM(Module))
                return true;
            else
            {
                needvent = true;
                return _ventroutine.Start(Module) == RState.Running;
            }

        }

        private bool VCEIsATM()
        {
            if (needvent)
            {
                RState ret = _ventroutine.Monitor();
                if (ret == RState.Timeout || ret == RState.Failed)
                {
                    return false;
                }
                return ret == RState.End;
            }
            else
                return Singleton<RouteManager>.Instance.seTM.VCEIsATM(Module);
        }

        private bool CheckVceStageDownDone()
        {
            if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE Stage Down failed");
            }
            return _vce.Status == RState.End;
        }

        private bool CheckVceOuterDoorOpenDone()
        {
            if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE OuterDoor Open failed");
            }
            return _vce.Status == RState.End;
        }

        private bool VceGotoLP()
        {
            return _vce.GotoLP();
        }

        private bool VceOuterDoorOpen()
        {
            if (Singleton<RouteManager>.Instance.seTM.VCEIsATM(Module) && Singleton<RouteManager>.Instance.seTM.VCEPressure(Module) >= SC.GetValue<int>($"{Module}.OutDoorOpenPressure"))
            {
                return _vce.OpenDoor();
            }
            else
            {
                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"{Module} is not ATM or Pressure not arrive {SC.GetValue<int>($"{Module}.OutDoorOpenPressure")}");
                return false;
            }
        }

        public void Abort()
        {

        }


    }
}