using System;
using System.Collections.Generic;

namespace SHARP_CLAS_UI
{
    public class LoaderConveyorOut : Conveyor
    {
        #region Enum
        #endregion

        #region Property
        public ConveyorOutSteps Step
        {
            get
            {
                return _step;
            }

            private set
            {
                _step = value;
            }
        }

        public override bool IsWorkEnd
        {
            get
            {
                if(Step == ConveyorOutSteps.S0000_WAIT)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public override bool IsStayPosition
        {
            get
            {
                return true;
            }
        }
        #endregion

        #region Field
        private ConveyorOutSteps _step;
        private ConveyorOutSteps _oldStep;
        private ConveyorHomeStep _homeStep;
        #endregion

        #region Construct
        public LoaderConveyorOut(Equipment equipment) : base(equipment, MotorAxis.LD_Tray_Out_Port, "LoaderConveyorOut")
        {
            Initialize(InputData.LD_Tray_Out_Conveyor_In_Sensor, InputData.LD_Tray_Out_Conveyor_In_Complete_Sensor, InputData.LD_Tray_Out_Conveyor_Lift_in_Sensor, InputData.LD_Tray_Out_Conveyor_Lift_in_Complete_Sensor);

            pauseDisableList.Add(ConveyorOutSteps.S1310_CONVEYOR_COMPLETE_SENSOR_CHECK);
            pauseDisableList.Add(ConveyorOutSteps.S1320_CONVEYOR_IN_SENSOR_CHECK);
            pauseDisableList.Add(ConveyorOutSteps.S1400_CONVEYOR_STOP);
            pauseDisableList.Add(ConveyorOutSteps.S1410_CONVEYOR_STOP_CHECK);

            AlignerX.Initialize(OutputData.LD_Tray_Out_Align_X_Sol_Valve, InputData.LD_Tray_Out_Align_X_1_Fwd_Sensor, InputData.LD_Tray_Out_Align_X_2_Fwd_Sensor, InputData.LD_Tray_Out_Align_X_1_Bwd_Sensor, InputData.LD_Tray_Out_Align_X_2_Bwd_Sensor,
                En_Alarm_List.AL_0594_LD_TRAY_OUT_ALIGN_X_1_FWD_SENSOR_CHECK, En_Alarm_List.AL_0595_LD_TRAY_OUT_ALIGN_X_2_FWD_SENSOR_CHECK, En_Alarm_List.AL_0596_LD_TRAY_OUT_ALIGN_X_1_BWD_SENSOR_CHECK, En_Alarm_List.AL_0597_LD_TRAY_OUT_ALIGN_X_2_BWD_SENSOR_CHECK);

            AlignerY.Initialize(OutputData.LD_Tray_Out_Align_Y_Sol_Valve, InputData.LD_Tray_Out_Align_Y_1_Fwd_Sensor, InputData.LD_Tray_Out_Align_Y_2_Fwd_Sensor, InputData.LD_Tray_Out_Align_Y_1_Bwd_Sensor, InputData.LD_Tray_Out_Align_Y_2_Bwd_Sensor,
                En_Alarm_List.AL_0598_LD_TRAY_OUT_ALIGN_Y_1_FWD_SENSOR_CHECK, En_Alarm_List.AL_0559_LD_TRAY_IN_ALIGN_Y_2_FWD_SENSOR_CHECK, En_Alarm_List.AL_0600_LD_TRAY_OUT_ALIGN_Y_1_BWD_SENSOR_CHECK, En_Alarm_List.AL_0601_LD_TRAY_OUT_ALIGN_Y_2_BWD_SENSOR_CHECK);

            MotorX.Check_Jog_Interlock = Jog_Interlock;
            MotorX.Check_Move_Interlock = Move_Interlock;
        }
        #endregion

        #region Function
        private bool Move_Interlock()
        {
            if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
            {
                return true;
            }

            return false;
        }

        private bool Jog_Interlock(bool positive)
        {
            if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
            {
                return true;
            }

            return false;
        }

        public void Init_Seq()
        {
            if (Step < ConveyorOutSteps.S1000_TRAY_UNLOADING_START || ConveyorOutSteps.S1999_TRAY_UNLOADING_END < Step)
                Step = ConveyorOutSteps.S0000_WAIT;

            _homeStep = ConveyorHomeStep.S0000_WAIT;
        }

        private void ExecuteStepAuto()
        {
            if(IsWorkEnd)
            {
                if(equipment.Cur_Main_Recipe.tray_info.LD_Tray_Empty_Tray_Count <= equipment.LoaderOutTrayCount)
                {
                    if(equipment.loader.LiftOut.IsStayPosition)
                    {
                        if(IsLiftInSensor && IsLiftInCompleteSensor)
                        {
                            if(!IsConveyorInCompleteSensor && !IsConveyorInSensor)
                            {
                                Step = ConveyorOutSteps.S1000_TRAY_UNLOADING_START;
                            }
                        }
                    }
                }
            }
        }

        public override void MonitoringStatus()
        {
            if (ConveyorOutSteps.S0000_WAIT <= Step && Step < ConveyorOutSteps.S1300_CONVEYOR_MOVE_OUT)
            {
                if (MotorX.MotionComplete == false)
                    Stop();
            }
            else
            {
                if (Alarm_Manager.Instance.Occured_List.Exists(X => X.Heavy == true) || Alarm_Manager.Instance.Occured_List.Exists(X => X.Code == En_Alarm_List.AL_0052_LD_LIGHT_CURTAIN_ALARM))
                {
                    if (MotorX.MotionComplete == false)
                    {
                        if(Alarm_Manager.Instance.Occured_List.Exists(x => x.Code == En_Alarm_List.AL_0052_LD_LIGHT_CURTAIN_ALARM))
                        {
                            equipment.Write_Exception_Log($"LD Conveyor Empty Light Curtain!, conveyor sensor : {IsConveyorInSensor}, conveyor in sensor : {IsConveyorInCompleteSensor}");
                        }

                        Stop();
                    }
                }
            }

            if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
            {
                if (MotorX.MotionComplete == false)
                {
                    Stop();
                }
            }
        }

        public override void ExecuteStep()
        {
            if (_oldStep != Step)
            {
                sequenceChangedTime.Restart();
                _oldStep = Step;
                WriteSequenceLog(Step.ToString());
            }

            AlignerX.ExecuteProcess();
            AlignerY.ExecuteProcess();

            //상시 Run.
            if (UnitMode != En_Equipment_Mode.Home)
            {
                UnloadingTray();
                AgvUnloading();
            }

            if (UnitMode == En_Equipment_Mode.Stop)
            {
                Init_Seq();
                isHomeComplete = false;
                return;
            }
            else if (UnitMode == En_Equipment_Mode.Pause)
            {
                sequenceChangedTime.Stop();
                return;
            }
            else if (UnitMode == En_Equipment_Mode.Home)
            {
                if (!IsHomeComplete)
                {
                    ExecuteHome();
                }

                return;
            }
            else if (UnitMode == En_Equipment_Mode.Auto || UnitMode == En_Equipment_Mode.Manual)
            {
                sequenceChangedTime.Start();

                if (equipment.equip_mode == En_Equipment_Mode.Pause)
                {
                    if (pauseDisableList.Contains(Step) == false)
                    {
                        UnitMode = En_Equipment_Mode.Pause;
                        return;
                    }
                }

                if (equipment.equip_mode == En_Equipment_Mode.Pause)
                {
                    if (pauseDisableList.Contains(Step) == false)
                    {
                        UnitMode = En_Equipment_Mode.Pause;
                    }
                }

                if (UnitMode == En_Equipment_Mode.Auto)
                {
                    ExecuteStepAuto();
                }

            }
        }

        private void Test()
        {
            if (UnitMode == En_Equipment_Mode.Stop)
            {
                // 장비 Stop시 즉시 전체 스탑 진행.
                UnitMode = En_Equipment_Mode.Stop;
            }
            // 장비상태 home or (장비상태 pause and 유닛 Home) 일시 진행.
            else if ((equipment.equip_mode == En_Equipment_Mode.Pause || equipment.equip_mode == En_Equipment_Mode.Home) && UnitMode == En_Equipment_Mode.Home)
            {
                // 장비 Home시 유닛 홈 진행 완료 확인 후 홈 진행.
                if (!IsHomeComplete)
                {

                }
            }
            else if (UnitMode == En_Equipment_Mode.Pause)
            {
                // 유닛 Puase 일 때 동작.
            }
            else if (UnitMode == En_Equipment_Mode.Auto || UnitMode == En_Equipment_Mode.Manual
                || UnitMode == En_Equipment_Mode.Pause)
            {
                if(UnitMode == En_Equipment_Mode.Auto)
                {
                    ExecuteStepAuto();
                }
                else if (UnitMode == En_Equipment_Mode.Pause)
                {
                    UnitMode = En_Equipment_Mode.Pause;
                }
            }
        }

        public void ExecuteHome()
        {
            switch (_homeStep)
            {
                case ConveyorHomeStep.S0000_WAIT:
                    {
                        _homeStep = ConveyorHomeStep.S1000_STATUS_CHECK;
                        break;
                    }
                case ConveyorHomeStep.S1000_STATUS_CHECK:
                    {
                        if (MotorX.ErrorStop)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0111_LD_TRAY_OUT_PORT_ERROR_STOP);
                        }
                        else if (MotorX.PowerOn == false)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0110_LD_TRAY_OUT_PORT_POWER_OFF);
                        }
                        else
                        {
                            _homeStep = ConveyorHomeStep.S1100_CONVEYOR_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorHomeStep.S1100_CONVEYOR_SENSOR_CHECK:
                    {
                        if (IsConveyorInSensor || IsConveyorInCompleteSensor)
                        {
                            if (IsConveyorInSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("LD Conveyor Out Home can't run.", "Conveyor in sensor is detected.");
                            }

                            if (IsConveyorInCompleteSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("LD Conveyor Out Home can't run.", "Conveyor in complete sensor is detected.");
                            }
                        }
                        else
                        {
                            _homeStep = ConveyorHomeStep.S1200_LIFT_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorHomeStep.S1200_LIFT_SENSOR_CHECK:
                    {
                        if (IsLiftInSensor || IsLiftInCompleteSensor)
                        {
                            if (IsLiftInSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("LD Conveyor Out Home can't run.", "Lift in sensor is detected.");
                            }

                            if (IsLiftInCompleteSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("LD Conveyor Out Home can't run.", "Lift in complete sensor is detected.");
                            }
                        }
                        else
                        {
                            _homeStep = ConveyorHomeStep.S2000_POSITION_CLEAR;
                        }
                        break;
                    }
                case ConveyorHomeStep.S2000_POSITION_CLEAR:
                    {
                        if (MotorX.Position_Clear())
                        {
                            _homeStep = ConveyorHomeStep.S9999_END;
                        }
                        break;
                    }
                case ConveyorHomeStep.S9999_END:
                    {
                        isHomeComplete = true;
                        _homeStep = ConveyorHomeStep.S0000_WAIT;
                        break;
                    }
            }
        }

        public void UnloadingTray()
        {
            switch(Step)
            {
                case ConveyorOutSteps.S1000_TRAY_UNLOADING_START:
                    {
                        Step = ConveyorOutSteps.S1100_LIFT_POSITION_STAY_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S1100_LIFT_POSITION_STAY_CHECK:
                    {
                        if(equipment.loader.LiftOut.IsStayPosition)
                        {
                            Step = ConveyorOutSteps.S1110_CONVEYOR_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1110_CONVEYOR_SENSOR_CHECK:
                    {
                        if(IsConveyorInCompleteSensor || IsConveyorInSensor)
                        {
                            if (IsConveyorInSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0590_LD_TRAY_OUT_CONVEYOR_IN_SENSOR_CHECK);
                            }

                            if (IsConveyorInCompleteSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0591_LD_TRAY_OUT_CONVEYOR_IN_COMPLETE_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S1120_LIFT_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1120_LIFT_SENSOR_CHECK:
                    {
                        if(IsLiftInCompleteSensor || IsLiftInSensor)
                        {
                            Step = ConveyorOutSteps.S1200_ALIGN_X_FWD;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S1400_CONVEYOR_STOP;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1200_ALIGN_X_FWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsForward)
                            {
                                Step = ConveyorOutSteps.S1220_ALIGN_Y_BWD;
                            }
                            else
                            {
                                AlignerX.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorOutSteps.S1220_ALIGN_Y_BWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsBackward)
                            {
                                Step = ConveyorOutSteps.S1240_WAIT_TIME;
                            }
                            else
                            {
                                AlignerY.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorOutSteps.S1240_WAIT_TIME:
                    {
                        if (sequenceChangedTime.Seconds > 2)
                        {
                            Step = ConveyorOutSteps.S1250_ALIGN_Y_FWD;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1250_ALIGN_Y_FWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsForward)
                            {
                                Step = ConveyorOutSteps.S1270_ALIGN_X_BWD;
                            }
                            else
                            {
                                AlignerY.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorOutSteps.S1270_ALIGN_X_BWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsBackward)
                            {
                                Step = ConveyorOutSteps.S1300_CONVEYOR_MOVE_OUT;
                            }
                            else
                            {
                                AlignerX.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorOutSteps.S1300_CONVEYOR_MOVE_OUT:
                    {
                        if (JogPositive())
                        {
                            Step = ConveyorOutSteps.S1310_CONVEYOR_COMPLETE_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1310_CONVEYOR_COMPLETE_SENSOR_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            if (!(Alarm_Manager.Instance.Occured_List.Exists(X => X.Heavy == true) || Alarm_Manager.Instance.Occured_List.Exists(X => X.Code == En_Alarm_List.AL_0052_LD_LIGHT_CURTAIN_ALARM)))
                            {
                                JogPositive();
                            }
                        }

                        if (IsConveyorInCompleteSensor || IsConveyorInSensor)
                        {
                            Step = ConveyorOutSteps.S1320_CONVEYOR_IN_SENSOR_CHECK;
                        }
                        else if (sequenceChangedTime.Seconds > equipment.Setting.Conveyor_Timeout)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0871_LD_TRAY_OUT_CONVEYOR_TIMEOUT);
                            Step = ConveyorOutSteps.S1400_CONVEYOR_STOP;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1320_CONVEYOR_IN_SENSOR_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            if (!(Alarm_Manager.Instance.Occured_List.Exists(X => X.Heavy == true) || Alarm_Manager.Instance.Occured_List.Exists(X => X.Code == En_Alarm_List.AL_0052_LD_LIGHT_CURTAIN_ALARM)))
                                JogPositive();
                        }

                        if (IsConveyorInSensor || (IsConveyorInCompleteSensor == false && IsConveyorInSensor == false && IsLiftInSensor == false && IsLiftInCompleteSensor == false))
                        {
                            Step = ConveyorOutSteps.S1400_CONVEYOR_STOP;
                        }
                        else if (sequenceChangedTime.Seconds > equipment.Setting.Conveyor_Timeout)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0871_LD_TRAY_OUT_CONVEYOR_TIMEOUT);
                            Step = ConveyorOutSteps.S1400_CONVEYOR_STOP;
                        }

                        break;
                    }
                case ConveyorOutSteps.S1400_CONVEYOR_STOP:
                    {
                        if (Stop())
                        {
                            Step = ConveyorOutSteps.S1410_CONVEYOR_STOP_CHECK;
                        }
                        break;
                    }
                case ConveyorOutSteps.S1410_CONVEYOR_STOP_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            Step = ConveyorOutSteps.S1999_TRAY_UNLOADING_END;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S1400_CONVEYOR_STOP;
                        }

                        break;
                    }
                case ConveyorOutSteps.S1999_TRAY_UNLOADING_END:
                    {
                        equipment.LoaderOutTrayCount = 0;

                        if (equipment.Mode.Agv_Skip)
                        {
                            equipment.Set_Load_Tray_Buzzer(true);
                            Step = ConveyorOutSteps.S0000_WAIT;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2000_AGV_UNLOADING_START;
                        }

                        break;
                    }
            }
        }

        private void AgvUnloading()
        {
            switch (Step)
            {
                case ConveyorOutSteps.S2000_AGV_UNLOADING_START:
                    {
                        Step = ConveyorOutSteps.S2100_EQP_UNLOAD_ENABLE_ON;
                        break;
                    }
                case ConveyorOutSteps.S2100_EQP_UNLOAD_ENABLE_ON:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Request_For_Transfer_LD_ULD, true);
                        Step = ConveyorOutSteps.S2110_EQP_UNLOAD_ENABLE_ON_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S2110_EQP_UNLOAD_ENABLE_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_LD_Out_Request_For_Transfer_LD_ULD))
                        {
                            Step = ConveyorOutSteps.S2120_AGV_UNLOAD_STATUS_ON_CHECK;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2100_EQP_UNLOAD_ENABLE_ON;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2120_AGV_UNLOAD_STATUS_ON_CHECK:
                    {
                        if (equipment.Mode.Agv_Skip)
                        {
                            equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Request_For_Transfer_LD_ULD, false);
                            Step = ConveyorOutSteps.S0000_WAIT;
                        }
                        else
                        {
                            if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_LD_Out_Moving_Load_Status))
                            {
                                Step = ConveyorOutSteps.S2130_EQP_UNLOAD_STATUS_ON;
                            }
                        }
                        break;
                    }
                case ConveyorOutSteps.S2130_EQP_UNLOAD_STATUS_ON:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Moving_Load_Status, true);
                        Step = ConveyorOutSteps.S0000_WAIT;
                        break;
                    }
                case ConveyorOutSteps.S2140_EQP_UNLOAD_STATUS_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_LD_Out_Moving_Load_Status))
                        {
                            Step = ConveyorOutSteps.S2150_AGV_UNLOAD_ENABLE_CONVEYOR_RUN_ON_CHECK;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2130_EQP_UNLOAD_STATUS_ON;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2150_AGV_UNLOAD_ENABLE_CONVEYOR_RUN_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_LD_Out_Request_For_Transfer_LD_ULD)
                            && equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_LD_Out_Conveyor_In_Operation))
                        {
                            Step = ConveyorOutSteps.S2200_EQP_CONVEYOR_RUN_ON;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2200_EQP_CONVEYOR_RUN_ON:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Conveyor_In_Operation, true);
                        Step = ConveyorOutSteps.S2210_EQP_CONVEYOR_RUN_ON_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S2210_EQP_CONVEYOR_RUN_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_LD_Out_Conveyor_In_Operation))
                        {
                            Step = ConveyorOutSteps.S2220_EQP_UNLOAD_ENABLE_OFF;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2200_EQP_CONVEYOR_RUN_ON;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2220_EQP_UNLOAD_ENABLE_OFF:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Request_For_Transfer_LD_ULD, false);
                        Step = ConveyorOutSteps.S2230_EQP_UNLOAD_ENABLE_OFF_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S2230_EQP_UNLOAD_ENABLE_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_LD_Out_Request_For_Transfer_LD_ULD) == false)
                        {
                            Step = ConveyorOutSteps.S2240_CONVEYOR_RUN;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2220_EQP_UNLOAD_ENABLE_OFF;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2240_CONVEYOR_RUN:
                    {
                        JogPositive();
                        Step = ConveyorOutSteps.S2300_AGV_CONVEYOR_RUN_UNLOAD_STATUS_UNLOAD_ENABLE_OFF_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S2300_AGV_CONVEYOR_RUN_UNLOAD_STATUS_UNLOAD_ENABLE_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_LD_Out_Moving_Load_Status) == false
                            && equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_LD_Out_Request_For_Transfer_LD_ULD) == false
                            && equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_LD_Out_Conveyor_In_Operation) == false)
                        {
                            Step = ConveyorOutSteps.S2310_CONVEYOR_STOP_CHECK;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2310_CONVEYOR_STOP_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            Step = ConveyorOutSteps.S2320_EQP_CONVEYOR_RUN_OFF;
                        }
                        else
                        {
                            Stop();
                        }
                        break;
                    }
                case ConveyorOutSteps.S2320_EQP_CONVEYOR_RUN_OFF:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Conveyor_In_Operation, false);
                        Step = ConveyorOutSteps.S2330_EQP_CONVEYOR_RUN_OFF_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S2330_EQP_CONVEYOR_RUN_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_LD_Out_Conveyor_In_Operation) == false)
                        {
                            Step = ConveyorOutSteps.S2340_EQP_UNLOAD_STATUS_OFF;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2320_EQP_CONVEYOR_RUN_OFF;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2340_EQP_UNLOAD_STATUS_OFF:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_LD_Out_Moving_Load_Status, false);
                        Step = ConveyorOutSteps.S2350_EQP_UNLOAD_STATUS_OFF_CHECK;
                        break;
                    }
                case ConveyorOutSteps.S2350_EQP_UNLOAD_STATUS_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_LD_Out_Moving_Load_Status) == false)
                        {
                            Step = ConveyorOutSteps.S2999_AGV_UNLOADING_END;
                        }
                        else
                        {
                            Step = ConveyorOutSteps.S2340_EQP_UNLOAD_STATUS_OFF;
                        }
                        break;
                    }
                case ConveyorOutSteps.S2999_AGV_UNLOADING_END:
                    {
                        Step = ConveyorOutSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void Unload()
        {
            Step = ConveyorOutSteps.S1000_TRAY_UNLOADING_START;
        }
        #endregion
    }
}