using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Routine;
using CyberX8_Core;
using CyberX8_RT.Devices.Dryer;
using System.Collections.Generic;
using MECF.Framework.Common.CommonData.Dryer;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.Alarm;

namespace CyberX8_RT.Modules.Dryer
{
    public class DryerRunRecipeRoutine : RoutineBase, IRoutine
    {
        #region step enum
        /// <summary>
        /// 步骤枚举
        /// </summary>
        private enum DryerRunRecipeStep
        {
            ControlPowerOn,
            HighOn,
            Delay,
            CheckPressureMinimum,
            DelayCheckPressureWarning,
            CheckPressureWarning,
            DelayCheckPressureError,
            CheckPressureError,
            DelayRecipeTime,
            LowerOn,
            End
        }
        #endregion

        #region 常量
        private const int PRESSURE_DELAY = 500;
        
        private const string EXHAUST_PRESSURE = "ExhaustPressure";
        #endregion

        #region 内部变量
        /// <summary>
        /// 设备对象
        /// </summary>
        private DryerDevice _device;
        /// <summary>
        /// HVD Recipe
        /// </summary>
        public HvdRecipe _hvdRecipe;
        /// <summary>
        /// minimum pressure
        /// </summary>
        private double _minimumPressure = 0;
        /// <summary>
        /// Check Pressure Warning Delay Second
        /// </summary>
        private int _pressureCheckWarningHoldoffSeconds;
        /// <summary>
        /// Warning Pressure value
        /// </summary>
        private double _pressureCheckWarningMMHG;
        /// <summary>
        /// Check Pressure Error Delay Second
        /// </summary>
        private int _pressureCheckErrorHoldoffSeconds;
        /// <summary>
        /// Error Pressure value
        /// </summary>
        private double _pressureCheckErrorMMHG;
        /// <summary>
        /// recipe时长
        /// </summary>
        private int _dryProcessTime;
        /// <summary>
        /// recipe里的DryTime时长
        /// </summary>
        public int _recipeDrytime;      
        
        #endregion

        #region 属性
        /// <summary>
        /// HVD Recipe
        /// </summary>
        public HvdRecipe HvdRecipe { get { return _hvdRecipe; } }
        /// <summary>
        /// LotTrack数据
        /// </summary>
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public DryerRunRecipeRoutine(string module) : base(module)
        {
        }        

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual abort dryer run recipe");
            _device.BlowerLowOn();
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(DryerRunRecipeStep.ControlPowerOn, () => _device.PowerControlOn(), () => { return _device.CommonData.PowerControl; }, _delay_1s)
                .Run(DryerRunRecipeStep.HighOn, () => _device.BlowerHighOn(),()=> { return _device.CommonData.BlowerHigh; }, _delay_1s)
                .DelayIf(DryerRunRecipeStep.Delay,!_device.Bypass,PRESSURE_DELAY)
                .RunIf(DryerRunRecipeStep.CheckPressureMinimum, !_device.Bypass, CheckPressureMinimum,_delay_1ms)
                .Delay(DryerRunRecipeStep.DelayCheckPressureWarning, _pressureCheckWarningHoldoffSeconds * 1000)
                .Run(DryerRunRecipeStep.CheckPressureWarning, CheckPressureWaring, _delay_1ms)
                .Delay(DryerRunRecipeStep.DelayCheckPressureError, _pressureCheckErrorHoldoffSeconds * 1000)
                .Run(DryerRunRecipeStep.CheckPressureError, CheckPressureError, _delay_1ms)
                .Delay(DryerRunRecipeStep.DelayRecipeTime, _dryProcessTime)
                .Run(DryerRunRecipeStep.LowerOn, () => _device.BlowerLowOn(), _delay_1ms)
                .End(DryerRunRecipeStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// 检验Minimum Pressure
        /// </summary>
        /// <returns></returns>
        private bool CheckPressureMinimum()
        {
            double pressure = _device.CommonData.ExhaustPressure;
            if(pressure>=_minimumPressure)
            {
                NotifyError(eEvent.ERR_DRYER, $"{pressure} is over minimum pressure {_minimumPressure}", 0);
                _device.BlowerLowOn();
                return false;
            }
            return true;
        }
        /// <summary>
        /// 检验Pressure是否低于Waring
        /// </summary>
        /// <returns></returns>
        private bool CheckPressureWaring()
        {
            double pressure = _device.CommonData.ExhaustPressure;
            if(pressure > _pressureCheckWarningMMHG)
            {
                string str = $"{pressure} is large than waring pressure {_pressureCheckWarningMMHG}";
                if (AlarmListManager.Instance.AddWarn(Module, "Exhaust Pressure",str))
                {
                    LOG.WriteLog(eEvent.WARN_DRYER, Module,str);
                }
            }
            return true;
        }
        /// <summary>
        /// 检验Pressure是否低于Error
        /// </summary>
        /// <returns></returns>
        private bool CheckPressureError()
        {
            double pressure = _device.CommonData.ExhaustPressure;
            if (pressure > _pressureCheckErrorMMHG)
            {
                NotifyError(eEvent.ERR_DRYER, $"{pressure} is large than error pressure {_pressureCheckErrorMMHG}",0);
                _device.BlowerLowOn();
                return false;
            }
            return true;
        }       
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objects"></param>
        /// <returns></returns>
        public RState Start(params object[] objects)
        {

            _hvdRecipe = objects[0] as HvdRecipe;

            if (_hvdRecipe == null)
            {
                NotifyError(eEvent.ERR_DRYER, "recipe is null",-1);
                return RState.Failed;
            }
            _device = DEVICE.GetDevice<DryerDevice>(Module);

            _recipeDrytime = _hvdRecipe.DryTime;
            _pressureCheckWarningHoldoffSeconds = SC.GetValue<int>("Dryer.PressureCheckWarningHoldoffSeconds");
            _pressureCheckWarningMMHG = SC.GetValue<double>("Dryer.PressureCheckWarningMMHG");
            _pressureCheckErrorHoldoffSeconds = SC.GetValue<int>("Dryer.PressureCheckErrorHoldoffSeconds");
            _pressureCheckErrorMMHG = SC.GetValue<double>("Dryer.PressureCheckErrorMMHG");
            _minimumPressure = SC.GetValue<double>("Dryer.MinimumPressure");
            int dryRecipeTime = _hvdRecipe.DryTime*1000;
            int processTime= dryRecipeTime-PRESSURE_DELAY- _pressureCheckWarningHoldoffSeconds*1000- _pressureCheckErrorHoldoffSeconds*1000;
            if(processTime>0)
            {
                _dryProcessTime = processTime;
            }
            else
            {
                _dryProcessTime = 1;
            }
            
            return Runner.Start(Module, "Start run dryer recipe");
        }
    }
}