using Aitex.Core.RT.Device;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.Persistent.Reservoirs;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.ToolLayout;
using PunkHPX8_Core;
using PunkHPX8_RT.Devices.AXIS;
using PunkHPX8_RT.Devices.PlatingCell;
using PunkHPX8_RT.Devices.Reservoir;
using System;
using System.Collections.Generic;
using System.Diagnostics.Eventing.Reader;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media.Imaging;

namespace PunkHPX8_RT.Modules.PlatingCell
{
    public class PlatingCellInitializeRoutine : RoutineBase, IRoutine
    {
        private enum InitializeStep
        {
            CheckPowerSupplierConnected,
            CheckClamShellClosed,
            VerticalGotoLoad,
            VerticalGotoLoadCheck,
            RotationHome,
            RotationHomeCheck,
            AngleEntryTilt,
            AngleEntryVertical,
            CheckClamShellOpen,
            OpenCAAndANIsoltaionValve,
            CheckCellFlowWait,
            CheckCellFlow,
            OpenCCRAndRinseValve,
            RinseDripIdleDelay,
            CloseCCRAndRinseValve,
            End
        }

        #region 内部变量
        /// <summary>
        /// 持久化对象
        /// </summary>
        private PlatingCellPersistentValue _persistentValue;
        /// <summary>
        /// 设备对象
        /// </summary>
        private PlatingCellDevice _platingCellDevice;
        /// <summary>
        /// 槽体对象
        /// </summary>
        private ReservoirDevice _reservoirDevice;
        /// <summary>
        /// Reservoir Recipe
        /// </summary>
        private ResRecipe _resRecipe;

        /// <summary>
        /// vertical axis
        /// </summary>
        private JetAxisBase _verticalAxis; 
        /// <summary>
        /// Rotation axis
        /// </summary>
        private JetAxisBase _rotationAxis;
        /// <summary>
        /// _flowFaultHoldOffTime 单位ms
        /// </summary>
        private int _flowFaultHoldOffTime = 1000;
        /// <summary>
        /// Cell Flow Start Low Limit
        /// </summary>
        private double _cellFlowStartLowLimit = 3.0;
        /// <summary>
        /// Anode flow start low limit
        /// </summary>
        private double _anFlowStartLowLimit = 0.5;
        /// <summary>
        /// Rinse Drip Idle Period
        /// </summary>
        private int _rinseDripIdlePeriod = 1000;
        #endregion

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

        /// <summary>
        /// 中止
        /// </summary>
        public void Abort()
        {
            Runner.Stop("Manual Abort");
        }
        /// <summary>
        /// 监控
        /// </summary>
        /// <returns></returns>
        public RState Monitor()
        {
            Runner.Run(InitializeStep.CheckPowerSupplierConnected, CheckPowerSupplierStatus, _delay_1ms)
                .Run(InitializeStep.CheckClamShellClosed, () => _platingCellDevice.ClamShellClose(), CheckClamShellClosed, _delay_1ms)
                .Run(InitializeStep.VerticalGotoLoad, VerticalGotoLoad, NullFun, 100)
                .WaitWithStopCondition(InitializeStep.VerticalGotoLoadCheck, CheckVerticalPositionStatus, CheckVerticalPositionRunStop)
                .Run(InitializeStep.RotationHome, RotationGotoHome, NullFun, 100)
                .WaitWithStopCondition(InitializeStep.RotationHomeCheck, CheckRotationPositionStatus, CheckRotationPositionRunStop)
                .Run(InitializeStep.AngleEntryTilt, () => _platingCellDevice.HeadtTiltAction(), CheckAngleTilt, _delay_1ms)
                .Run(InitializeStep.AngleEntryVertical, () => _platingCellDevice.HeadtVerticalAction(), CheckAngleVertical, _delay_1ms)
                .Run(InitializeStep.CheckClamShellClosed, () => _platingCellDevice.ClamShellOpen(), CheckClamShellOpen, _delay_1ms)
                .Run(InitializeStep.OpenCAAndANIsoltaionValve, OpenReservoirIsolationValve,_delay_1ms)
                .Delay(InitializeStep.CheckCellFlowWait, _flowFaultHoldOffTime)
                .Run(InitializeStep.CheckCellFlow, CheckCellFlow, _delay_1ms)
                .Run(InitializeStep.OpenCCRAndRinseValve, OpenCCRAndRinseValve, _delay_1ms)
                .Delay(InitializeStep.RinseDripIdleDelay, _rinseDripIdlePeriod)
                .Run(InitializeStep.CloseCCRAndRinseValve, CloseCCRAndRinseValve, _delay_1ms)
                .End(InitializeStep.End, NullFun, _delay_1ms);
            return Runner.Status;
        }
        /// <summary>
        /// 检查cell flow
        /// </summary>
        /// <returns></returns>
        private bool CheckCellFlow()
        {
            if ("Manual".Equals(_persistentValue.OperatingMode))
            {
                if(_reservoirDevice.ReservoirData.CaFlow < _cellFlowStartLowLimit)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, $"CA flow{_reservoirDevice.ReservoirData.CaFlow} is lower than cellFlowStartLowLimit{_cellFlowStartLowLimit}");
                    _reservoirDevice.CAIsolationOff();
                    return false;
                }
                if (_reservoirDevice.ReservoirData.AnFlow < _anFlowStartLowLimit)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, $"AN flow{_reservoirDevice.ReservoirData.AnFlow} is lower than cellFlowStartLowLimit{_anFlowStartLowLimit}");
                    _reservoirDevice.ANIsolationOff();
                    return false;
                }
            }
            else
            {
                if (_reservoirDevice.ReservoirData.CaFlow < _resRecipe.CAFlowRateErrorLow)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, $"CA flow{_reservoirDevice.ReservoirData.CaFlow} is lower than resRecipe CAFlowRateErrorLow{_resRecipe.CAFlowRateErrorLow}");
                    return false;
                }
                if (_reservoirDevice.ReservoirData.AnFlow < _resRecipe.ANFlowRateErrorLow)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, $"AN flow{_reservoirDevice.ReservoirData.AnFlow} is lower than resRecipe ANFlowRateErrorLow{_resRecipe.ANFlowRateErrorLow}");
                    return false;
                }
            }
            return true;
        }
        /// <summary>
        /// 打开reservoir Isolation valve
        /// </summary>
        /// <returns></returns>
        private bool OpenReservoirIsolationValve()
        {
            return _reservoirDevice.ANIsolationOn() && _reservoirDevice.ANIsolationOn();
        }
        /// <summary>
        /// 打开CCR/Rinse valve
        /// </summary>
        /// <returns></returns>
        private bool OpenCCRAndRinseValve()
        {
            return _platingCellDevice.CCREnableAction() && _platingCellDevice.RinseEnableAction();
        }
        /// <summary>
        /// 关闭CCR/Rinse valve
        /// </summary>
        /// <returns></returns>
        private bool CloseCCRAndRinseValve()
        {
            return _platingCellDevice.CCRDisableAction() && _platingCellDevice.RinseDisableAction();
        }
        /// <summary>
        /// vertical 运动到Load位置
        /// </summary>
        /// <returns></returns>
        private bool VerticalGotoLoad()
        {
            if(_verticalAxis != null )
            {
                if (!_verticalAxis.IsSwitchOn)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "Vertical is not Power On");
                    return false;
                }
                else if (!_verticalAxis.IsHomed)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "Vertical is not Home,Home vertical first");
                    return false;
                }
                return _verticalAxis.PositionStation("Load", true);

            }
            else
            {
                LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "vertical axis is null");
                return false;
            }   
        }
        /// <summary>
        /// vertical 运动到Load位置
        /// </summary>
        /// <returns></returns>
        private bool RotationGotoHome()
        {
            if (_rotationAxis != null)
            {
                if (!_rotationAxis.IsSwitchOn)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "Roation is not Power On");
                    return false;
                }
                else if (!_rotationAxis.IsHomed)
                {
                    LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "Rotation is not Home,Home Rotation first");
                    return false;
                }
                return _rotationAxis.PositionStation("Home", true);

            }
            else
            {
                LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "Rotation axis is null");
                return false;
            }
        }
        /// <summary>
        /// 检查ClamShell是否closed
        /// </summary>
        /// <returns></returns>
        private bool CheckClamShellClosed()
        {
            return _platingCellDevice.PlatingCellDeviceData.ClamShellClose;
        }
        /// <summary>
        /// 检查ClamShell是否Open
        /// </summary>
        /// <returns></returns>
        private bool CheckClamShellOpen()
        {
            return !_platingCellDevice.PlatingCellDeviceData.ClamShellClose;
        }
        /// <summary>
        /// 检查Angle是否Tilt
        /// </summary>
        /// <returns></returns>
        private bool CheckAngleTilt()
        {
            return _platingCellDevice.PlatingCellDeviceData.HeadTilt;
        }
        /// <summary>
        /// 检查Angle是否Vertical
        /// </summary>
        /// <returns></returns>
        private bool CheckAngleVertical()
        {
            return !_platingCellDevice.PlatingCellDeviceData.HeadTilt;
        }
        /// <summary>
        /// 检验Metal A/B 面PowerSupplier通讯状况
        /// </summary>
        /// <returns></returns>
        private bool CheckPowerSupplierStatus()
        {
            if (!_platingCellDevice.PowerSupplier.IsConnected)
            {
                LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, "power is not connected");
                return false;
            }
            return true;
        }
        /// <summary>
        /// 检验Vertical移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckVerticalPositionStatus()
        {
            return _verticalAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Vertical是否还在运动
        /// </summary>
        /// <returns></returns>
        private bool CheckVerticalPositionRunStop()
        {
            return _verticalAxis.Status == RState.Failed;
        }
        /// <summary>
        /// 检验Rotation移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Rotaion是否还在运动
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionRunStop()
        {
            return _rotationAxis.Status == RState.Failed;
        }

        /// <summary>
        /// 获取Reservoir设备
        /// </summary>
        /// <returns></returns>
        private ReservoirDevice GetReservoirDevice()
        {
            string reservoir = ReservoirItemManager.Instance.GetReservoirByPlatingCell(Module.ToString());
            return DEVICE.GetDevice<ReservoirDevice>(reservoir);
        }
        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _persistentValue = (PlatingCellPersistentValue)objs[0];
            _platingCellDevice = DEVICE.GetDevice<PlatingCellDevice>(Module);
            _reservoirDevice = GetReservoirDevice();
            _flowFaultHoldOffTime = SC.GetValue<int>("PlatingCell.FlowFaultHoldOffTime");
            _rinseDripIdlePeriod = SC.GetValue<int>("PlatingCell.RinseDripIdlePeriod");
            _cellFlowStartLowLimit = SC.GetValue<double>("PlatingCell.CellFlowStartLowLimit");
            _anFlowStartLowLimit = SC.GetValue<double>("PlatingCell.ANFlowStartLowLimit");
            if("PlatingCell1".Equals(Module) || "PlatingCell2".Equals(Module))
            {
                _verticalAxis = DEVICE.GetDevice<JetAxisBase>("PlatingCell1_2.Vertical");
            }
            else
            {
                _verticalAxis = DEVICE.GetDevice<JetAxisBase>("PlatingCell3_4.Vertical");
            }
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
            string reservoir = ReservoirItemManager.Instance.GetReservoirByPlatingCell(Module.ToString());
            ReservoirDevice reservoirDevice = DEVICE.GetDevice<ReservoirDevice>(reservoir);
            if (reservoirDevice == null)
            {
                LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, $"{reservoir} device is null");
                return RState.Failed;
            }
            if (reservoirDevice.Recipe == null)
            {
                LOG.WriteLog(eEvent.ERR_PLATINGCELL, Module, $"{reservoir} current recipe is null");
                return RState.Failed;
            }
            _resRecipe = reservoirDevice.Recipe;

            return Runner.Start(Module, "Start Reservoir Initialize");
        }


    }
}