using Aitex.Core.RT.Device;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Utilities;
using CyberX8_Core;
using CyberX8_RT.Devices.AXIS;
using CyberX8_RT.Devices.PUF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CyberX8_RT.Modules.PUF
{
    public class PufNoWaferPickRoutine : RoutineBase, IRoutine
    {
        private enum PufPickStep
        {
            VacuumLevelCheck,
            RotationLoaderPickup,
            RotationLoaderPickupWait,
            VerticalFlip,
            VerticalFlipWait,
            FlipSide,
            FlipSideWait,
            VerticalLoaderPickup,
            VerticalLoaderPickupWait,
            VacuumOn,
            StickDistance,
            StickDistanceWait,
            StickDistanceCheck,
            ReVerticalFlip,
            ReVerticalFlipWait,
            VerticalPark,
            VerticalParkWait,
            RotationPark,
            RotationParkWait,
            End
        }
        #region 常量
        private const string SideA = "SideA";
        private const string SideB = "SideB";
        private const string VACUUM_OFF= "VacuumOff";
        private const string WAFER_PRESENT = "WaferPresent";
        #endregion

        #region 内部变量
        private JetAxisBase _flipAxis;
        private JetAxisBase _rotationAxis;
        private JetAxisBase _verticalAxis;
        private PufDistanceSensor _distanceSensor;
        private PufVacuum _vacuum;
        
        private string _side;
        private bool _enableCheckStickDistanceStatus = false;
        #endregion
        public PufNoWaferPickRoutine(string module) : base(module)
        {
            _flipAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.Flip");
            _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.Rotation");
            _verticalAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.Vertical");
            _vacuum = DEVICE.GetDevice<PufVacuum>($"{module}.Vacuum");
            _distanceSensor = DEVICE.GetDevice<PufDistanceSensor>($"{module}.DistanceSensor");
        }

        public void Abort()
        {
            Runner.Stop("Manual Abort");
        }

        public RState Monitor()
        {
            Runner.Run(PufPickStep.VacuumLevelCheck, CheckVacuumLevel, 100)
                .Run(PufPickStep.RotationLoaderPickup,()=> { return _rotationAxis.PositionStation("LoaderPickup"); },NullFun,100)
                .WaitWithStopCondition(PufPickStep.RotationLoaderPickupWait,CheckRotationPositionStatus,CheckRotationPositionRunStop)
                .Run(PufPickStep.VerticalFlip, () => { return _verticalAxis.PositionStation("Flip"); },NullFun,100)
                .WaitWithStopCondition(PufPickStep.VerticalFlipWait, CheckVerticalPositionStatus, CheckVerticalPositionRunStop)
                .Run(PufPickStep.FlipSide, () => { return _flipAxis.PositionStation(_side); }, NullFun, 100)
                .WaitWithStopCondition(PufPickStep.FlipSideWait, CheckFlipPositionStatus, CheckFlipPositionRunStop)
                .Run(PufPickStep.VerticalLoaderPickup, () => { return _verticalAxis.PositionStation("LoaderPickup"); }, NullFun, 100)
                .WaitWithStopCondition(PufPickStep.VerticalLoaderPickupWait, CheckVerticalPositionStatus, CheckVerticalPositionRunStop)
                .Run(PufPickStep.VacuumOn,VacuumOn,CheckWaferPresent,5000)
                .Run(PufPickStep.StickDistance,StickDistance,100)
                .WaitWithStopCondition(PufPickStep.StickDistanceWait,CheckVerticalPositionStatus,CheckVerticalPositionRunStop)
                .Wait(PufPickStep.StickDistanceCheck,CheckStickDistanceStatus,1000)
                .Run(PufPickStep.ReVerticalFlip, () => { return _verticalAxis.PositionStation("Flip"); }, NullFun, 100)
                .WaitWithStopCondition(PufPickStep.ReVerticalFlipWait, CheckVerticalPositionStatus, CheckVerticalPositionRunStop)
                .Run(PufPickStep.VerticalPark, () => { return _verticalAxis.PositionStation("Park"); }, NullFun, 100)
                .WaitWithStopCondition(PufPickStep.VerticalParkWait, CheckVerticalPositionStatus, CheckVerticalPositionRunStop)
                .Run(PufPickStep.RotationPark, () => { return _rotationAxis.PositionStation("Park"); }, NullFun, 100)
                .WaitWithStopCondition(PufPickStep.RotationParkWait, CheckRotationPositionStatus, CheckRotationPositionRunStop)
                .End(PufPickStep.End, NullFun);

            return Runner.Status; 
        }
        /// <summary>
        /// 检验VacuumLevel
        /// </summary>
        /// <returns></returns>
        private bool CheckVacuumLevel()
        {
            if (_side == SideA)
            {
                return _vacuum.ChuckAVacuumStatus == VACUUM_OFF;
            }
            else if (_side == SideB)
            {
                return _vacuum.ChuckBVacuumStatus == VACUUM_OFF;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 检验存在Wafer
        /// </summary>
        /// <returns></returns>
        private bool CheckWaferPresent()
        {
            if (_side == SideA)
            {
                return _vacuum.ChuckAVacuumStatus==WAFER_PRESENT;
            }
            else if (_side == SideB)
            {
                return _vacuum.ChuckBVacuumStatus==WAFER_PRESENT;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 检验Rotation移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionStatus()
        {
            return _rotationAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Rotation是否还在运动
        /// </summary>
        /// <returns></returns>
        private bool CheckRotationPositionRunStop()
        {
            return _rotationAxis.Status == RState.Failed;
        }
        /// <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>
        /// 检验Flip移动状态
        /// </summary>
        /// <returns></returns>
        private bool CheckFlipPositionStatus()
        {
            return _flipAxis.Status == RState.End;
        }
        /// <summary>
        /// 检验Flip是否还在运动
        /// </summary>
        /// <returns></returns>
        private bool CheckFlipPositionRunStop()
        {
            return _flipAxis.Status == RState.Failed;
        }
        /// <summary>
        /// 打开Vacuum
        /// </summary>
        /// <returns></returns>
        private bool VacuumOn()
        {
            if(_side==SideA)
            {
                return _vacuum.VacuumAOn();
            }
            else if(_side==SideB)
            {
                return _vacuum.VacuumBOn();
            }
            return false;
        }
        /// <summary>
        /// Stick Distance
        /// </summary>
        /// <returns></returns>
        private bool StickDistance()
        {
            return _distanceSensor.GotoStickDistance();
        }
        /// <summary>
        /// Stick Distance检验结果
        /// </summary>
        /// <returns></returns>
        private bool CheckStickDistanceStatus()
        {
            if (_enableCheckStickDistanceStatus)
            {
                if (_side == "SideA")
                {
                    return _distanceSensor.CheckStickDistanceStatus();
                }
                else
                {
                    return true;
                }
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public RState Start(params object[] objs)
        {
            _side = objs[0].ToString();
            _enableCheckStickDistanceStatus = SC.GetValue<bool>($"{Module}.EnableCheckStickDistanceStatus");
            Runner.Start(Module, "NoWaferPick");
            return RState.Running;
        }
    }
}