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.Common.RecipeCenter;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.SubstrateTrackings;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.AXIS;
using PunkHPX8_RT.Devices.VpwCell;
using PunkHPX8_RT.Devices.VpwMain;
using PunkHPX8_RT.Modules.VpwMain;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Modules.VpwCell
{
    public class VpwManualPrepareRoutine : RoutineBase, IRoutine
    {
        private enum PrepareStep
        {
            CheckPreCondition,
            Purge,
            PurgeDelay,
            WaitPurge,
            RotationPositionOffset,
            WaitRotation,
            CloseDrip,
            Delay,
            WaitWafer,
            ChamberUp,
            CloseDrain,
            CheckLoopDO,
            End
        }
        #region 内部变量
        /// <summary>
        /// recipe
        /// </summary>
        private VpwRecipe _recipe;
        /// <summary>
        /// 电机
        /// </summary>
        private JetAxisBase _rotationAxis;
        /// <summary>
        /// 设备
        /// </summary>
        private VpwCellDevice _vpwCellDevice;
        /// <summary>
        /// Main设备
        /// </summary>
        private VpwMainDevice _mainDevice;
        /// <summary>
        /// VPW Entity
        /// </summary>
        private VpwMainEntity _vpwMainEntity;
        /// <summary>
        /// 延迟时间
        /// </summary>
        private int _putDownAfterDripClose = 2000;
        /// <summary>
        /// 等待Wafer放入时间
        /// </summary>
        private int _waitForWaferTime = 300000;
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public VpwManualPrepareRoutine(string module) : base(module)
        {
        }
        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(PrepareStep.CheckPreCondition,CheckPreCondition,_delay_1ms)
                .RunIf(PrepareStep.Purge,_recipe.PurgeEnable,Purge,_delay_1ms)
                .DelayIf(PrepareStep.PurgeDelay, _recipe.PurgeEnable, 500)
                .WaitWithStopConditionIf(PrepareStep.WaitPurge,_recipe.PurgeEnable,CheckPurgeStatus,CheckPurgeStopStatus)
                .Run(PrepareStep.RotationPositionOffset,RotationPositionOffset,_delay_1ms)
                .WaitWithStopCondition(PrepareStep.WaitRotation,CheckRotationStatus,CheckRotationStopStatus)
                .Run(PrepareStep.CloseDrip,()=>_vpwCellDevice.FlowDripOff(),_delay_1ms)
                .Delay(PrepareStep.Delay,_putDownAfterDripClose)
                .Wait(PrepareStep.WaitWafer,CheckWaferExsit,_waitForWaferTime)
                .Run(PrepareStep.ChamberUp,ChamberUp,CheckChamberClosed)
                .Run(PrepareStep.CloseDrain,_vpwCellDevice.DrainValveOff,_delay_1ms)
                .Run(PrepareStep.CheckLoopDO,CheckLoopDO,_delay_1ms)
                .End(PrepareStep.End,NullFun,_delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// Purge routine
        /// </summary>
        /// <returns></returns>
        private bool Purge()
        {
            if (_vpwMainEntity == null)
            {
                NotifyError(eEvent.ERR_VPW, "VPW Main not exist", -1);
                return false;
            }
            if (_vpwMainEntity.IsIdle)
            {
                return _vpwMainEntity.CheckToPostMessage<VPWMainState, VPWMainMsg>(eEvent.ERR_VPW, Module, (int)VPWMainMsg.Purge);
            }
            else if (_vpwMainEntity.State == VPWMainState.Purgeing)
            {
                return true;
            }
            else
            {
                NotifyError(eEvent.ERR_VPW, $"State {_vpwMainEntity.State} cannot purge", -1);
                return false;
            }
        }
        /// <summary>
        /// 检验Purge执行是否结束
        /// </summary>
        /// <returns></returns>
        private bool CheckPurgeStatus()
        {
            return _vpwMainEntity.IsIdle;
        }
        /// <summary>
        /// 检验Purger执行是否出现异常
        /// </summary>
        /// <returns></returns>
        private bool CheckPurgeStopStatus()
        {
            return _vpwMainEntity.IsError;
        }
        /// <summary>
        /// Position运行至offset
        /// </summary>
        /// <returns></returns>
        private bool RotationPositionOffset()
        {
            bool result= _rotationAxis.PositionStation("ChuckPlaceOffset");
            if (!result)
            {
                NotifyError(eEvent.ERR_VPW, "rotation start position to ChuckPlaceOffset failed", -1);
            }
            return result;
        }
        /// <summary>
        /// 检验电机是否完成运动
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验电机运动是否出现异常
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationStopStatus()
        {
            bool result= _rotationAxis.Status == RState.Failed;
            if (result)
            {
                NotifyError(eEvent.ERR_VPW, "rotation position to ChuckPlaceOffset failed", -1);
            }
            return result;
        }
        /// <summary>
        /// 检验是否存在Wafer
        /// </summary>
        /// <returns></returns>
        private bool CheckWaferExsit()
        {
            // todo 临时注释，后面需要改回来
            //return WaferManager.Instance.CheckHasWafer(Module, 0);
            return true;
        }
        /// <summary>
        /// chamber up
        /// </summary>
        /// <returns></returns>
        private bool ChamberUp()
        {
            bool result=_mainDevice.ChamberUp();
            if (!result)
            {
                NotifyError(eEvent.ERR_VPW, "chamber up failed", -1);
            }
            return result;
        }
        /// <summary>
        /// 检验Chamber是否关闭
        /// </summary>
        /// <returns></returns>
        private bool CheckChamberClosed()
        {
            return _mainDevice.CommonData.ChamberClosed && !_mainDevice.CommonData.ChamberOpened;
        }
        /// <summary>
        /// Check LoopDO数值
        /// </summary>
        /// <returns></returns>
        private bool CheckLoopDO()
        {
            double loopDoValue = _vpwCellDevice.LoopDOValue;
            bool result = loopDoValue < _recipe.DiwLoopDoSet;
            if (!result) 
            {
                NotifyError(eEvent.ERR_VPW, $"LoopDO value {loopDoValue} is less than {_recipe.DiwLoopDoSet}", -1);
            }
            return result;
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _recipe=(VpwRecipe)objs[0];
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            _vpwCellDevice = DEVICE.GetDevice<VpwCellDevice>(Module);
            _mainDevice = DEVICE.GetDevice<VpwMainDevice>(ModuleName.VPWMain1.ToString());
            _putDownAfterDripClose = SC.GetValue<int>($"{Module}.PutDownAfterDripClose");
            _waitForWaferTime = SC.GetValue<int>($"{Module}.WaitForWaferTime") * 1000;
            _vpwMainEntity = Singleton<RouteManager>.Instance.GetModule<VpwMainEntity>(ModuleName.VPWMain1.ToString());
            return Runner.Start(Module, $"{Module} prepare");
        }
        /// <summary>
        /// 检验前置条件
        /// </summary>
        /// <returns></returns>
        private bool CheckPreCondition()
        {
            if (!_rotationAxis.IsSwitchOn)
            {
                NotifyError(eEvent.ERR_VPW,"rotaion is not switch on",-1);
                return false;
            }
            if (!_rotationAxis.IsHomed)
            {
                NotifyError(eEvent.ERR_VPW, "rotaion is not homed", -1);
                return false;
            }
            return true;
        }

        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="step"></param>
        public RState Retry(int step)
        {
            if (_recipe == null)
            {
                NotifyError(eEvent.ERR_RINSE, "recipe is null", -1);
                return RState.Failed;
            }
            List<Enum> preStepIds = new List<Enum>();
            return Runner.Retry(PrepareStep.CheckPreCondition, preStepIds, Module, "Prepare Retry");
        }
    }
}