using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Mainframe.LLs;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadLocks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

            SetSlitValve,
            LLRoutine,

            Delay,
            Delay1,
            CloseTMToLLVent,
            PumpDownToBase,
        }

        private TMPressureBalanceRoutine _balanceRoutine;
        private TMPressureBalancePidRoutine _pidBalanceRoutine;

        private SicTM _tm;
        private LoadLock _ll;

        private bool _needPressureBalance;
        private bool _userPidBalance;

        public TMServoToLLRoutine()
        {
            Module = ModuleName.TM.ToString();
            Name = "PID";
            _tm = DEVICE.GetDevice<SicTM>($"{ ModuleName.System.ToString()}.{ ModuleName.TM.ToString()}");
            //_ll = DEVICE.GetDevice<SicLoadLock>($"{ModuleName.LoadLock}.{ModuleName.LoadLock}");
        }

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

            _balanceRoutine = new TMPressureBalanceRoutine();
            _pidBalanceRoutine = new TMPressureBalancePidRoutine();
            _balanceRoutine.Init(ModuleName.PM1);
            _pidBalanceRoutine.Init(ModuleName.PM1);

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

            ModuleName[] modules = new ModuleName[] { ModuleName.LoadLock, ModuleName.PM1 };
            foreach (var moduleName in modules)
            {
                if (!_tm.CheckSlitValveClose(moduleName))
                {
                    EV.PostAlarmLog(Module, $"Can not pump, {moduleName} slit valve not closed");
                    return Result.FAIL;
                }
            }

            string reason;
            if (!_tm.SetFastPumpValve(false, out reason) || !_tm.SetFastVentValve(false, out reason))
            {
                EV.PostAlarmLog(Module, $"Can not turn off valves, {reason}");
                return Result.FAIL;
            }

            Notify("Start");

            return Result.RUN;
        }


        public override Result Monitor()
        {
            try
            {
                if (_userPidBalance)
                {
                    ExecuteRoutine((int)RoutineStep.ChamberBalance, _pidBalanceRoutine);
                }
                else
                {
                    ExecuteRoutine((int)RoutineStep.ChamberBalance, _balanceRoutine);
                }
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                return Result.FAIL;
            }


            Notify("Finished");

            return Result.DONE;
        }

        public override void Abort()
        {
            if (_userPidBalance)
            {
                _pidBalanceRoutine.Abort();
            }
            else
            {
                _balanceRoutine.Abort();
            }
        }
    }
}