using System;

namespace SHARP_CLAS_UI
{
    public class UnloaderConveyorIn : Conveyor
    {
        #region Property
        public ConveyorInSteps Step
        {
            get
            {
                return _step;
            }

            private set
            {
                _step = value;
            }
        }

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

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

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

        #region Construct
        public UnloaderConveyorIn(Equipment equipment) : base(equipment, MotorAxis.ULD_Tray_IN_Port, "UnloaderConveyorIn")
        {
            Initialize(InputData.ULD_Empty_In_Conveyor_In_Sensor, InputData.ULD_Empty_In_Conveyor_In_Complete_Sensor, InputData.ULD_Empty_In_Conveyor_Lift_In_Sensor, InputData.ULD_Empty_In_Conveyor_Lift_In_Complete_Sensor);

            pauseDisableList.Add(ConveyorInSteps.S1210_LIFT_IN_SENSOR_CHECK);
            pauseDisableList.Add(ConveyorInSteps.S1220_LIFT_COMPLETE_SENSOR_CHECK);
            pauseDisableList.Add(ConveyorInSteps.S1230_CONVEYOR_STOP);

            pauseDisableList.Add(ConveyorInSteps.S2310_CONVEYOR_IN_COMPLETE_SENSOR_CHECK);
            pauseDisableList.Add(ConveyorInSteps.S2320_CONVEYOR_IN_SENSOR_CHECK);
            pauseDisableList.Add(ConveyorInSteps.S2330_CONVEYOR_STOP);

            AlignerX.Initialize(OutputData.ULD_Empty_In_Align_X_Sol_Valve, InputData.ULD_Empty_In_Align_X_1_Fwd_Sensor, InputData.ULD_Empty_In_Align_X_2_Fwd_Sensor, InputData.ULD_Empty_In_Align_X_1_Bwd_Sensor, InputData.ULD_Empty_In_Align_X_2_Bwd_Sensor,
                En_Alarm_List.AL_0704_ULD_TRAY_EMPTY_ALIGN_X_1_FWD_SENSOR_CHECK, En_Alarm_List.AL_0705_ULD_TRAY_EMPTY_ALIGN_X_2_FWD_SENSOR_CHECK, En_Alarm_List.AL_0706_ULD_TRAY_EMPTY_ALIGN_X_1_BWD_SENSOR_CHECK, En_Alarm_List.AL_0707_ULD_TRAY_EMPTY_ALIGN_X_2_BWD_SENSOR_CHECK);

            AlignerY.Initialize(OutputData.ULD_Empty_In_Align_Y_Sol_Valve, InputData.ULD_Empty_In_Align_Y_1_Fwd_Sensor, InputData.ULD_Empty_In_Align_Y_2_Fwd_Sensor, InputData.ULD_Empty_In_Align_Y_1_Bwd_Sensor, InputData.ULD_Empty_In_Align_Y_2_Bwd_Sensor,
                En_Alarm_List.AL_0708_ULD_TRAY_EMPTY_ALIGN_Y_1_FWD_SENSOR_CHECK, En_Alarm_List.AL_0709_ULD_TRAY_EMPTY_ALIGN_Y_2_FWD_SENSOR_CHECK, En_Alarm_List.AL_0710_ULD_TRAY_EMPTY_ALIGN_Y_1_BWD_SENSOR_CHECK, En_Alarm_List.AL_0711_ULD_TRAY_EMPTY_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 < ConveyorInSteps.S2000_TRAY_UNLOADING_START || ConveyorInSteps.S2999_TRAY_UNLOADING_END < Step)
                Step = ConveyorInSteps.S0000_WAIT;

            _homeStep = ConveyorHomeStep.S0000_WAIT;
        }

        public void ExecuteStepAuto()
        {
            if(Step == ConveyorInSteps.S0000_WAIT)
            {
                if (equipment.UnloaderInTrayCount <= 0 && equipment.unloader.LiftIn.IsStayPosition
                    && IsLiftInSensor == false && IsLiftInCompleteSensor == false)
                {
                    if(equipment.Mode.Agv_Skip)
                    {
                        Step = ConveyorInSteps.S1000_TRAY_LOADING_START;
                    }
                    else
                    {
                        //AGV Load 추가.
                        if (IsConveyorInCompleteSensor || IsConveyorInSensor)
                        {
                            Step = ConveyorInSteps.S1000_TRAY_LOADING_START;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0100_AGV_LOADING_START;
                        }
                    }
                }
            }
        }

        public override void MonitoringStatus()
        {
            if (((ConveyorInSteps.S1000_TRAY_LOADING_START <= Step && Step < ConveyorInSteps.S1200_CONVEYOR_MOVE_IN)
               && (ConveyorInSteps.S1230_CONVEYOR_STOP <= Step && Step <= ConveyorInSteps.S1999_TRAY_LOADING_END)) || Step == ConveyorInSteps.S0000_WAIT)
            {
                if (!MotorX.MotionComplete)
                    MotorX.Move_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_0053_ULD_LIGHT_CURTAIN_ALARM))
                {
                    sequenceChangedTime.Start();

                    if (!MotorX.MotionComplete)
                    {
                        if (Alarm_Manager.Instance.Occured_List.Exists(x => x.Code == En_Alarm_List.AL_0053_ULD_LIGHT_CURTAIN_ALARM))
                        {
                            equipment.Write_Exception_Log($"ULD Conveyor Empty Light Curtain!, conveyor sensor : {IsConveyorInSensor}, conveyor in sensor : {IsConveyorInCompleteSensor}");
                        }

                        MotorX.Move_Stop();
                    }
                }
            }

            if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
            {
                if (MotorX.MotionComplete == false)
                {
                    MotorX.Move_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();
                AgvLoading();
            }

            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 == false)
                {
                    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 (UnitMode == En_Equipment_Mode.Auto)
                    ExecuteStepAuto();

                LoadingTray();
            }
        }

        private 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_0501_ULD_TRAY_EMPTY_ERROR_STOP);
                        }
                        else if (!MotorX.PowerOn)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0500_ULD_TRAY_EMPTY_POWER_OFF);
                        }
                        else
                        {
                            _homeStep = ConveyorHomeStep.S1200_LIFT_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorHomeStep.S1100_CONVEYOR_SENSOR_CHECK:
                    {
                        if (IsConveyorInSensor || IsConveyorInCompleteSensor)
                        {
                            if (IsConveyorInSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Conveyor Empty Home can't run.", "Conveyor in sensor is detected.");
                            }

                            if (IsConveyorInCompleteSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Conveyor Empty 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("ULD Conveyor Empty Home can't run.", "Lift in sensor is detected.");
                            }

                            if (IsLiftInCompleteSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Conveyor Empty 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;
                    }
            }
        }

        private void AgvLoading()
        {
            switch (Step)
            {
                case ConveyorInSteps.S0100_AGV_LOADING_START:
                    {
                        Step = ConveyorInSteps.S0110_EQP_LOAD_ENABLE_ON;
                        break;
                    }
                case ConveyorInSteps.S0110_EQP_LOAD_ENABLE_ON:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD, true);
                        Step = ConveyorInSteps.S0120_EQP_LOAD_ENABLE_ON_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0120_EQP_LOAD_ENABLE_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD))
                        {
                            Step = ConveyorInSteps.S0130_AGV_LOAD_STATUS_ON_CHECK;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0110_EQP_LOAD_ENABLE_ON;
                        }
                        break;
                    }
                case ConveyorInSteps.S0130_AGV_LOAD_STATUS_ON_CHECK:
                    {
                        if (equipment.Mode.Agv_Skip)
                        {
                            equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD, false);
                            Step = ConveyorInSteps.S0000_WAIT;
                        }
                        else
                        {
                            if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_ULD_Empty_Moving_Load_Status))
                            {
                                Step = ConveyorInSteps.S0140_EQP_LOAD_STATUS_ON;
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S0140_EQP_LOAD_STATUS_ON:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Moving_Load_Status, true);
                        Step = ConveyorInSteps.S0150_EQP_LOAD_STATUS_ON_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0150_EQP_LOAD_STATUS_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_ULD_Empty_Moving_Load_Status))
                        {
                            Step = ConveyorInSteps.S0160_AGV_LOAD_ENABLE_ON_STOP_REQUEST_OFF_CHECK;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0140_EQP_LOAD_STATUS_ON;
                        }
                        break;
                    }
                case ConveyorInSteps.S0160_AGV_LOAD_ENABLE_ON_STOP_REQUEST_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD))
                        {
                            Step = ConveyorInSteps.S0200_EQP_CONVEYOR_RUN_ON;
                        }
                        break;
                    }
                case ConveyorInSteps.S0200_EQP_CONVEYOR_RUN_ON:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Conveyor_In_Operation, true);
                        Step = ConveyorInSteps.S0210_EQP_CONVEYOR_RUN_ON_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0210_EQP_CONVEYOR_RUN_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_ULD_Empty_Conveyor_In_Operation))
                        {
                            JogNegative();
                            Step = ConveyorInSteps.S0220_EQP_LOAD_ENABLE_OFF;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0200_EQP_CONVEYOR_RUN_ON;
                        }
                        break;
                    }
                case ConveyorInSteps.S0220_EQP_LOAD_ENABLE_OFF:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD, false);
                        Step = ConveyorInSteps.S0230_EQP_LOAD_ENABLE_OFF_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0230_EQP_LOAD_ENABLE_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_ULD_Empty_Conveyor_In_Operation))
                        {
                            Step = ConveyorInSteps.S0240_AGV_CONVEYOR_RUN_ON_CHECK;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0220_EQP_LOAD_ENABLE_OFF;
                        }
                        break;
                    }
                case ConveyorInSteps.S0240_AGV_CONVEYOR_RUN_ON_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_ULD_Empty_Conveyor_In_Operation))
                        {
                            Step = ConveyorInSteps.S0250_CONVEYOR_RUN;
                        }
                        break;
                    }
                case ConveyorInSteps.S0250_CONVEYOR_RUN:
                    {
                        Step = ConveyorInSteps.S0300_CONVEYOR_COMPLETE_SENSOR_ON_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0300_CONVEYOR_COMPLETE_SENSOR_ON_CHECK:
                    {
                        if (IsConveyorInCompleteSensor)
                        {
                            Step = ConveyorInSteps.S0310_CONVEYOR_STOP;
                        }
                        break;
                    }
                case ConveyorInSteps.S0310_CONVEYOR_STOP:
                    {
                        if (Stop())
                        {
                            Step = ConveyorInSteps.S0320_CONVEYOR_STOP_CHECK;
                        }
                        break;
                    }
                case ConveyorInSteps.S0320_CONVEYOR_STOP_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            Step = ConveyorInSteps.S0330_EQP_CONVEYOR_RUN_OFF;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0310_CONVEYOR_STOP;
                        }
                        break;
                    }
                case ConveyorInSteps.S0330_EQP_CONVEYOR_RUN_OFF:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Conveyor_In_Operation, false);
                        Step = ConveyorInSteps.S0340_EQP_CONVEYOR_RUN_OFF_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0340_EQP_CONVEYOR_RUN_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_ULD_Empty_Conveyor_In_Operation) == false)
                        {
                            Step = ConveyorInSteps.S0350_EQP_LOAD_STATUS_OFF;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0330_EQP_CONVEYOR_RUN_OFF;
                        }
                        break;
                    }
                case ConveyorInSteps.S0350_EQP_LOAD_STATUS_OFF:
                    {
                        equipment.Board_Control.IO_manager.Set_Output(OutputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD, false);
                        Step = ConveyorInSteps.S0360_EQP_LOAD_STATUS_OFF_CHECK;
                        break;
                    }
                case ConveyorInSteps.S0360_EQP_LOAD_STATUS_OFF_CHECK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Output(OutputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD) == false)
                        {
                            Step = ConveyorInSteps.S0370_AGV_CONVEYOR_OFF_LOAD_STATUS_OFF_LOAD_ENABLE_OFF_CEHCK;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S0350_EQP_LOAD_STATUS_OFF;
                        }
                        break;
                    }
                case ConveyorInSteps.S0370_AGV_CONVEYOR_OFF_LOAD_STATUS_OFF_LOAD_ENABLE_OFF_CEHCK:
                    {
                        if (equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_ULD_Empty_Conveyor_In_Operation) == false
                            && equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_ULD_Empty_Request_For_Transfer_LD_ULD) == false
                            && equipment.Board_Control.IO_manager.Get_Input(InputData.AGV_ULD_Empty_Moving_Load_Status) == false)
                        {
                            Step = ConveyorInSteps.S0999_AGV_LOADING_END;
                        }
                        break;
                    }
                case ConveyorInSteps.S0999_AGV_LOADING_END:
                    {
                        Step = ConveyorInSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void LoadingTray()
        {
            switch (Step)
            {
                case ConveyorInSteps.S1000_TRAY_LOADING_START:
                    {
                        Step = ConveyorInSteps.S1100_LIFT_POSITION_STAY_CHECK;
                        break;
                    }
                case ConveyorInSteps.S1100_LIFT_POSITION_STAY_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsStayPosition)
                        {
                            Step = ConveyorInSteps.S1110_CONVEYOR_IN_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorInSteps.S1110_CONVEYOR_IN_SENSOR_CHECK:
                    {
                        if (IsConveyorInSensor || IsConveyorInCompleteSensor)
                        {
                            Step = ConveyorInSteps.S1120_LIFT_IN_SENSOR_CHECK;
                        }
                        else
                        {
                            if(sequenceChangedTime.Seconds > 10)
                            {
                                sequenceChangedTime.Start();
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0912_ULD_TRAY_EMPTY_IS_EMPTY);
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1120_LIFT_IN_SENSOR_CHECK:
                    {
                        if (IsLiftInSensor || IsLiftInCompleteSensor)
                        {
                            if (IsLiftInSensor)
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0702_ULD_TRAY_EMPTY_CONVEYOR_LIFT_IN_SENSOR_CHECK);

                            if (IsLiftInCompleteSensor)
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0703_ULD_TRAY_EMPTY_CONVEYOR_LIFT_IN_COMPLETE_SENSOR_CHECK);
                        }
                        else
                        {
                            Step = ConveyorInSteps.S1130_ALIGN_X_BWD;
                        }
                        break;
                    }
                case ConveyorInSteps.S1130_ALIGN_X_BWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsBackward)
                            {
                                Step = ConveyorInSteps.S1140_ALIGN_Y_FWD;
                            }
                            else
                            {
                                AlignerX.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1140_ALIGN_Y_FWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsForward)
                            {
                                Step = ConveyorInSteps.S1200_CONVEYOR_MOVE_IN;
                            }
                            else
                            {
                                AlignerY.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1200_CONVEYOR_MOVE_IN:
                    {
                        if (equipment.sm.Get_Bit(Input_Memory_Address.UnLoading_Light_Curtain_Det))
                        {
                            if (JogPositive())
                            {
                                Step = ConveyorInSteps.S1210_LIFT_IN_SENSOR_CHECK;
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1210_LIFT_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_0053_ULD_LIGHT_CURTAIN_ALARM)))
                            {
                                JogPositive();
                            }
                        }
                        else
                        {
                            if (IsLiftInSensor)
                            {
                                Step = ConveyorInSteps.S1220_LIFT_COMPLETE_SENSOR_CHECK;
                            }
                            if (sequenceChangedTime.Seconds > equipment.Setting.Conveyor_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0872_ULD_TRAY_EMPTY_CONVEYOR_TIMEOUT);
                                Step = ConveyorInSteps.S1230_CONVEYOR_STOP;
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1220_LIFT_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_0053_ULD_LIGHT_CURTAIN_ALARM)))
                            {
                                JogPositive();
                            }
                        }
                        else
                        {
                            if (IsLiftInCompleteSensor)
                            {
                                Step = ConveyorInSteps.S1230_CONVEYOR_STOP;
                            }
                            else if (sequenceChangedTime.Seconds > equipment.Setting.Conveyor_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0872_ULD_TRAY_EMPTY_CONVEYOR_TIMEOUT);
                                Step = ConveyorInSteps.S1230_CONVEYOR_STOP;
                            }
                        }

                        break;
                    }
                case ConveyorInSteps.S1230_CONVEYOR_STOP:
                    {
                        if (Stop())
                        {
                            Step = ConveyorInSteps.S1300_ALIGN_X_FWD;
                        }
                        break;
                    }
                case ConveyorInSteps.S1300_ALIGN_X_FWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsForward)
                            {
                                Step = ConveyorInSteps.S1320_ALIGN_Y_BWD;
                            }
                            else
                            {
                                AlignerX.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1320_ALIGN_Y_BWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsBackward)
                            {
                                Step = ConveyorInSteps.S1340_WAIT_TIME;
                            }
                            else
                            {
                                AlignerY.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1340_WAIT_TIME:
                    {
                        if (sequenceChangedTime.Seconds > 2)
                        {
                            Step = ConveyorInSteps.S1400_ALIGN_Y_FWD;
                        }
                        break;
                    }
                case ConveyorInSteps.S1400_ALIGN_Y_FWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsForward)
                            {
                                Step = ConveyorInSteps.S1420_ALIGN_X_BWD;
                            }
                            else
                            {
                                AlignerY.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1420_ALIGN_X_BWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsBackward)
                            {
                                Step = ConveyorInSteps.S1999_TRAY_LOADING_END;
                            }
                            else
                            {
                                AlignerX.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S1999_TRAY_LOADING_END:
                    {
                        if (IsLiftInSensor || IsLiftInCompleteSensor)
                        {
                            equipment.unloader.LiftIn.IsFirstTray = true;
                            equipment.sm.Set_Value(Process_Memory_Address.ULD_Tray_Empty_Count, equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Empty_Tray_Count);
                        }

                        Step = ConveyorInSteps.S0000_WAIT;

                        break;
                    }
            }
        }

        public void UnloadingTray()
        {
            switch (Step)
            {
                case ConveyorInSteps.S2000_TRAY_UNLOADING_START:
                    {
                        Step = ConveyorInSteps.S2100_LIFT_POSITION_STAY_CHECK;
                        break;
                    }
                case ConveyorInSteps.S2100_LIFT_POSITION_STAY_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsStayPosition)
                        {
                            Step = ConveyorInSteps.S2110_LIFT_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorInSteps.S2110_LIFT_SENSOR_CHECK:
                    {
                        if (IsLiftInSensor || IsLiftInCompleteSensor)
                        {
                            Step = ConveyorInSteps.S2120_CONVEYOR_SENSOR_CHECK;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S2330_CONVEYOR_STOP;
                        }
                        break;
                    }
                case ConveyorInSteps.S2120_CONVEYOR_SENSOR_CHECK:
                    {
                        if (IsConveyorInSensor || IsConveyorInCompleteSensor)
                        {
                            if (IsConveyorInSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0700_ULD_TRAY_EMPTY_CONVEYOR_IN_SENSOR_CHECK);
                            }

                            if (IsConveyorInCompleteSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0701_ULD_TRAY_EMPTY_CONVEYOR_IN_COMPLETE_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = ConveyorInSteps.S2200_ALIGN_X_FWD;
                        }
                        break;
                    }
                case ConveyorInSteps.S2200_ALIGN_X_FWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsForward)
                            {
                                Step = ConveyorInSteps.S2220_ALIGN_Y_BWD;
                            }
                            else
                            {
                                AlignerX.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S2220_ALIGN_Y_BWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsBackward)
                            {
                                Step = ConveyorInSteps.S2240_WAIT_TIME;
                            }
                            else
                            {
                                AlignerY.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S2240_WAIT_TIME:
                    {
                        if (sequenceChangedTime.Seconds > 2)
                        {
                            Step = ConveyorInSteps.S2250_ALIGN_Y_FWD;
                        }
                        break;
                    }
                case ConveyorInSteps.S2250_ALIGN_Y_FWD:
                    {
                        if (AlignerY.IsWorkEnd)
                        {
                            if (AlignerY.IsForward)
                            {
                                Step = ConveyorInSteps.S2270_ALIGN_X_BWD;
                            }
                            else
                            {
                                AlignerY.Forward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S2270_ALIGN_X_BWD:
                    {
                        if (AlignerX.IsWorkEnd)
                        {
                            if (AlignerX.IsBackward)
                            {
                                Step = ConveyorInSteps.S2300_CONVEYOR_MOVE_OUT;
                            }
                            else
                            {
                                AlignerX.Backward();
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S2300_CONVEYOR_MOVE_OUT:
                    {
                        if (JogNegative())
                        {
                            Step = ConveyorInSteps.S2310_CONVEYOR_IN_COMPLETE_SENSOR_CHECK;
                        }
                        break;
                    }
                case ConveyorInSteps.S2310_CONVEYOR_IN_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_0053_ULD_LIGHT_CURTAIN_ALARM)))
                            {
                                JogNegative();
                            }
                        }
                        else
                        {
                            if (IsConveyorInCompleteSensor || IsConveyorInSensor)
                            {
                                Step = ConveyorInSteps.S2320_CONVEYOR_IN_SENSOR_CHECK;
                            }
                            else if (sequenceChangedTime.Seconds > equipment.Setting.Conveyor_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0872_ULD_TRAY_EMPTY_CONVEYOR_TIMEOUT);
                                Step = ConveyorInSteps.S2330_CONVEYOR_STOP;
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S2320_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_0053_ULD_LIGHT_CURTAIN_ALARM)))
                            {
                                JogNegative();
                            }
                        }
                        else
                        {
                            if (IsConveyorInSensor || (IsConveyorInCompleteSensor == false && IsConveyorInSensor == false && IsLiftInSensor == false && IsLiftInCompleteSensor == false))
                            {
                                Step = ConveyorInSteps.S2330_CONVEYOR_STOP;
                            }
                            else if (sequenceChangedTime.Seconds > equipment.Setting.Conveyor_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0872_ULD_TRAY_EMPTY_CONVEYOR_TIMEOUT);
                                Step = ConveyorInSteps.S2330_CONVEYOR_STOP;
                            }
                        }
                        break;
                    }
                case ConveyorInSteps.S2330_CONVEYOR_STOP:
                    {
                        if (Stop())
                        {
                            Step = ConveyorInSteps.S2340_CONVEYOR_STOP_CHECK;
                        }
                        break;
                    }
                case ConveyorInSteps.S2340_CONVEYOR_STOP_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            Step = ConveyorInSteps.S2999_TRAY_UNLOADING_END;
                        }
                        else
                        {
                            Step = ConveyorInSteps.S2330_CONVEYOR_STOP;
                        }
                        break;
                    }
                case ConveyorInSteps.S2999_TRAY_UNLOADING_END:
                    {
                        Step = ConveyorInSteps.S0000_WAIT;
                        break;
                    }
            }
        }
        
        public void Load()
        {
            Step = ConveyorInSteps.S1000_TRAY_LOADING_START;
        }

        public void Unload()
        {
            Step = ConveyorInSteps.S2000_TRAY_UNLOADING_START;
        }
        #endregion
    }
}