using System;

namespace SHARP_CLAS_UI
{
    public class UnloaderReverseStage : ReverseStage
    {
        #region Enum
        public enum StageSteps
        {
            S0000_WAIT,

            S1000_PICK_AOI_STAGE_START,
            S1100_VACUUM_ON,
            S1110_AOI_STAGE_VACUUM_OFF,
            S1120_DATA_SET,

            S9000_SCRAP_START,
            S9100_VACUUM_OFF,
            S9110_DATA_SET,
            S9999_STEP_END,
        }
        #endregion

        #region Property
        public bool IsPlaceEnable
        {
            get
            {
                if(IsWorkEnd && IsStayPosition && IsExist == false)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public bool IsPickEnable
        {
            get
            {
                if (IsExist && Step == UnloaderReverseStageSteps.S2230_PANEL_EXIST_CHECK)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public override Panel_Info Panel1
        {
            get
            {
                return Panel_Info_Manager.Instance.Get_Panel_Info(Panel_Info_Names.ULD_Reverse_Stage_1);
            }
            set
            {
                Panel_Info_Manager.Instance.Set_Panel_Info(Panel_Info_Names.ULD_Reverse_Stage_1, value);
            }
        }

        public override Panel_Info Panel2
        {
            get
            {
                return Panel_Info_Manager.Instance.Get_Panel_Info(Panel_Info_Names.ULD_Reverse_Stage_2);
            }
            set
            {
                Panel_Info_Manager.Instance.Set_Panel_Info(Panel_Info_Names.ULD_Reverse_Stage_2, value);
            }
        }

        public UnloaderReverseStageSteps Step
        {
            get
            {
                return _step;
            }

            set
            {
                _step = value;
            }
        }

        public bool IsPositionZ1Up
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_Z_Up_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorZ1.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionZ1Down
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_Z_Down_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorZ1.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionR1Degree0
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_T_0_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorR1.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionR1Degree180
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_T_180_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorR1.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionZ2Up
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_Z_Up_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorZ2.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionZ2Down
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_Z_Down_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorZ2.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionR2Degree0
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_T_0_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorR2.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

        public bool IsPositionR2Degree180
        {
            get
            {
                object value;
                double get_position;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_T_180_Position, out value);
                get_position = double.Parse($"{value}");

                return MotorR2.Is_Inposition(get_position, equipment.Setting.Inposition_Offset);
            }
        }

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

        public override bool IsStayPosition
        {
            get
            {
                if (IsPositionR1Degree180 && IsPositionR2Degree180 && IsPositionZ1Down && IsPositionZ2Down)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        #endregion

        #region Field
        private UnloaderReverseStageSteps _step;
        private UnloaderReverseStageSteps _oldStep;
        private ReverseStageHomeSteps _homeStep;

        public StageSteps _stage1Step;
        public StageSteps _stage2Step;
        
        public Time_Checker Tact_Move = new Time_Checker();
        #endregion

        #region Construct
        public UnloaderReverseStage(Equipment equipment) : base(equipment, MotorAxis.ULD_Rotation_Unit_Z_1, MotorAxis.ULD_Rotation_Unit_R_1, MotorAxis.ULD_Rotation_Unit_Z_2, MotorAxis.ULD_Rotation_Unit_R_2, "UnloaderReverseStage")
        {
            Step = UnloaderReverseStageSteps.S0000_WAIT;
            _oldStep = UnloaderReverseStageSteps.S0000_WAIT;

            Stage1.Initialize(OutputData.ULD_Cell_Reverse_1_Vaccum_On_Sol_Valve, OutputData.ULD_Cell_Reverse_1_Blow_On_Sol_Valve, InputData.ULD_Cell_Reverse_1_Vaccum_On_Check, En_Alarm_List.AL_0840_ULD_REVERSE_1_VACUUM_ON_CHECK);
            Stage2.Initialize(OutputData.ULD_Cell_Reverse_2_Vaccum_On_Sol_Valve, OutputData.ULD_Cell_Reverse_2_Blow_On_Sol_Valve, InputData.ULD_Cell_Reverse_2_Vaccum_On_Check, En_Alarm_List.AL_0841_ULD_REVERSE_2_VACUUM_ON_CHECK);

            pauseDisableList.Add(UnloaderReverseStageSteps.S1205_Z_POSITION_CHECK);
            pauseDisableList.Add(UnloaderReverseStageSteps.S1215_R_POSITION_CHECK);
            pauseDisableList.Add(UnloaderReverseStageSteps.S1225_Z_POSITION_CHECK);
            pauseDisableList.Add(UnloaderReverseStageSteps.S2205_Z_POSITION_CHECK);
            pauseDisableList.Add(UnloaderReverseStageSteps.S2215_R_POSITION_CHECK);
            pauseDisableList.Add(UnloaderReverseStageSteps.S2225_Z_POSITION_CHECK);

            MotorR1.Check_Jog_Interlock = Jog_Interlock;
            MotorR1.Check_Move_Interlock = Move_Interlock;
            MotorZ1.Check_Jog_Interlock = Jog_Interlock;
            MotorZ1.Check_Move_Interlock = Move_Interlock;

            MotorR2.Check_Jog_Interlock = Jog_Interlock;
            MotorR2.Check_Move_Interlock = Move_Interlock;
            MotorZ2.Check_Jog_Interlock = Jog_Interlock;
            MotorZ2.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()
        {
            Step = UnloaderReverseStageSteps.S0000_WAIT;
            _homeStep = ReverseStageHomeSteps.S0000_WAIT;

            Tact_Move.Reset();
        }

        private void ExecuteAuto()
        {
            if(Step == UnloaderReverseStageSteps.S0000_WAIT)
            {
                if(IsExist)
                {
                    Step = UnloaderReverseStageSteps.S2000_PANEL_UNLOAD_START;
                }
                else
                {
                    if(equipment.Cur_Main_Recipe.tray_info.Uld_Reverse && equipment.unloader.Handler1.IsStayPosition && equipment.unloader.Handler1.IsExist == false && equipment.after.AoiStage.IsPickEnable)
                    {
                        Step =UnloaderReverseStageSteps.S1000_PICK_AOI_STAGE_START;
                    }
                }
            }
        }

        public override void MonitoringStatus()
        {
            if (UnitMode == En_Equipment_Mode.Auto || UnitMode == En_Equipment_Mode.Manual)
            {
                if (Stage1.IsWorkEnd && Stage1.VacuumSolOn && Stage1.IsVacuumSensor == false)
                {
                    Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0840_ULD_REVERSE_1_VACUUM_ON_CHECK);
                }

                if (Stage2.IsWorkEnd && Stage2.VacuumSolOn && Stage2.IsVacuumSensor == false)
                {
                    Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0841_ULD_REVERSE_2_VACUUM_ON_CHECK);
                }
            }

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

                if (MotorR1.MotionComplete == false)
                {
                    MotorR1.Move_Stop();
                }

                if (MotorZ2.MotionComplete == false)
                {
                    MotorZ2.Move_Stop();
                }

                if (MotorR2.MotionComplete == false)
                {
                    MotorR2.Move_Stop();
                }
            }
        }

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

            Seq_Stage1Step();
            Seq_Stage2Step();

            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;
            }

            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)
                    ExecuteAuto();

                Seq_PickAoiStage();
                Seq_Unload();
            }
        }
        
        public void ExecuteHome()
        {
            switch (_homeStep)
            {
                case ReverseStageHomeSteps.S0000_WAIT:
                    {
                        _homeStep = ReverseStageHomeSteps.S1000_STATUS_CHECK;
                        break;
                    }
                case ReverseStageHomeSteps.S1000_STATUS_CHECK:
                    {
                        if (MotorR1.ErrorStop || MotorZ1.ErrorStop || MotorR2.ErrorStop || MotorZ2.ErrorStop)
                        {
                            if (MotorR1.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0371_ULD_ROTATION_UNIT_R_1_ERROR_STOP);
                            }
                            if (MotorZ1.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0381_ULD_ROTATION_UNIT_Z_1_ERROR_STOP);
                            }
                            if (MotorR2.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0391_ULD_ROTATION_UNIT_R_2_ERROR_STOP);
                            }
                            if (MotorZ2.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0211_LD_ROTATION_UNIT_Z_2_ERROR_STOP);
                            }
                        }
                        else if (!MotorR1.PowerOn || !MotorZ1.PowerOn || !MotorR2.PowerOn || !MotorZ2.PowerOn)
                        {
                            if (MotorR1.PowerOn)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0370_ULD_ROTATION_UNIT_R_1_POWER_OFF);
                            }
                            if (MotorZ1.PowerOn)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0380_ULD_ROTATION_UNIT_Z_1_POWER_OFF);
                            }
                            if (MotorR2.PowerOn)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0390_ULD_ROTATION_UNIT_R_2_POWER_OFF);
                            }
                            if (MotorZ2.PowerOn)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0400_ULD_ROTATION_UNIT_Z_2_POWER_OFF);
                            }
                        }
                        else
                        {
                            if (equipment.unloader.Handler1.IsHomeComplete && equipment.after.Handler2.IsHomeComplete)
                                _homeStep = ReverseStageHomeSteps.S2000_Z_HOME_START;
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S2000_Z_HOME_START:
                    {
                        if (MotorZ1.Home())
                        {
                            if (MotorZ2.Home())
                            {
                                homeCheckedTime.Restart();
                                _homeStep = ReverseStageHomeSteps.S2100_Z_HOME_CHECK;
                            }
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S2100_Z_HOME_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (!MotorZ1.IsHomed || !MotorZ2.IsHomed)
                        {
                            if (MotorZ1.Homing == false && MotorZ1.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0381_ULD_ROTATION_UNIT_Z_1_ERROR_STOP);
                            }

                            if (MotorZ2.Homing == false && MotorZ2.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0401_ULD_ROTATION_UNIT_Z_2_ERROR_STOP);
                            }
                        }
                        else
                        {
                            _homeStep = ReverseStageHomeSteps.S2200_R_HOME_START;
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S2200_R_HOME_START:
                    {
                        if (MotorR1.Home())
                        {
                            if (MotorR2.Home())
                            {
                                homeCheckedTime.Restart();
                                _homeStep = ReverseStageHomeSteps.S2300_R_HOME_CHECK;
                            }
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S2300_R_HOME_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (!MotorR1.IsHomed || !MotorR2.IsHomed)
                        {
                            if (MotorR1.Homing == false && MotorR1.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0371_ULD_ROTATION_UNIT_R_1_ERROR_STOP);
                            }

                            if (MotorR2.Homing == false && MotorR2.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0391_ULD_ROTATION_UNIT_R_2_ERROR_STOP);
                            }
                        }
                        else
                        {
                            _homeStep = ReverseStageHomeSteps.S3000_R_MOVE_180_DEG;
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S3000_R_MOVE_180_DEG:
                    {
                        if (Move_R_1_Deg_180_Position())
                        {
                            if (Move_R_2_Deg_180_Position())
                            {
                                homeCheckedTime.Restart();
                                _homeStep = ReverseStageHomeSteps.S3100_R_POSITION_CHECK;
                            }
                        }

                        break;
                    }
                case ReverseStageHomeSteps.S3100_R_POSITION_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (MotorR1.ErrorStop || MotorR2.ErrorStop)
                        {
                            if (MotorR1.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0371_ULD_ROTATION_UNIT_R_1_ERROR_STOP);
                            }
                            if (MotorR2.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0401_ULD_ROTATION_UNIT_Z_2_ERROR_STOP);
                            }
                        }
                        else if (MotorR1.MotionComplete && MotorR2.MotionComplete)
                        {
                            if (IsPositionR1Degree180 && IsPositionR2Degree180)
                            {
                                _homeStep = ReverseStageHomeSteps.S3200_Z_MOVE_DOWN_POSITION;
                            }
                            else
                            {
                                if (!IsPositionR1Degree180)
                                {
                                    Interlock_Manager.Add_Interlock_Msg("ULD Reverse Home can't run.", "Reverse R 1 is not 180 deg.");
                                }

                                if (!IsPositionR2Degree180)
                                {
                                    Interlock_Manager.Add_Interlock_Msg("ULD Reverse Home can't run.", "Reverse R 2 is not 180 deg.");
                                }
                            }
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S3200_Z_MOVE_DOWN_POSITION:
                    {
                        if (Move_Z_1_Down_Position())
                        {
                            if (Move_Z_2_Down_Position())
                            {
                                homeCheckedTime.Restart();
                                _homeStep = ReverseStageHomeSteps.S3300_Z_POSITION_CHECK;
                            }
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S3300_Z_POSITION_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (MotorZ1.ErrorStop || MotorZ2.ErrorStop)
                        {
                            if (MotorZ1.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0381_ULD_ROTATION_UNIT_Z_1_ERROR_STOP);
                            }
                            if (MotorZ2.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0211_LD_ROTATION_UNIT_Z_2_ERROR_STOP);
                            }
                        }
                        else if (MotorZ1.MotionComplete && MotorZ2.MotionComplete)
                        {
                            if (IsPositionZ1Down && IsPositionZ2Down)
                            {
                                _homeStep = ReverseStageHomeSteps.S9999_END;
                            }
                            else
                            {
                                if (!IsPositionZ1Down)
                                {
                                    Interlock_Manager.Add_Interlock_Msg("ULD Reverse Home can't run.", "Reverse Z 1 is not down position.");
                                }

                                if (!IsPositionZ2Down)
                                {
                                    Interlock_Manager.Add_Interlock_Msg("ULD Reverse Home can't run.", "Reverse Z 2 is not down position.");
                                }
                            }
                        }
                        break;
                    }
                case ReverseStageHomeSteps.S9999_END:
                    {
                        isHomeComplete = true;
                        _homeStep = ReverseStageHomeSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void Seq_PickAoiStage()
        {
            switch(Step)
            {
                case UnloaderReverseStageSteps.S1000_PICK_AOI_STAGE_START:
                    {
                        Tact_Move.Start();
                        Step = UnloaderReverseStageSteps.S1100_HANDLER_1_POSITION_CHECK;
                        break;
                    }
                case UnloaderReverseStageSteps.S1100_HANDLER_1_POSITION_CHECK:
                    {
                        double position = equipment.unloader.Handler1.Get_Position_Y_Stay();

                        if (position >= equipment.unloader.Handler1.MotorY.Position || equipment.unloader.Handler1.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
                        {
                            Step = UnloaderReverseStageSteps.S1110_HANDLER_2_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1110_HANDLER_2_POSITION_CHECK:
                    {
                        double position = equipment.after.Handler2.Get_Position_Y_Stay();

                        if (position >= equipment.after.Handler2.MotorY.Position || equipment.after.Handler2.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
                        {
                            Step = UnloaderReverseStageSteps.S1200_MOVE_Z_UP_POSITION;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1200_MOVE_Z_UP_POSITION:
                    {
                        if(Move_Z_1_Up_Position() && Move_Z_2_Up_Position())
                        {
                            Step = UnloaderReverseStageSteps.S1205_Z_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1205_Z_POSITION_CHECK:
                    {
                        if (MotorZ1.MotionComplete && MotorZ2.MotionComplete)
                        {
                            if (IsPositionZ1Up && IsPositionZ2Up)
                            {
                                Step = UnloaderReverseStageSteps.S1210_MOVE_R_DEG_0;
                            }
                            else
                            {
                                Step = UnloaderReverseStageSteps.S1200_MOVE_Z_UP_POSITION;
                            }
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1210_MOVE_R_DEG_0:
                    {
                        if (Move_R_1_Deg_0_Position() && Move_R_2_Deg_0_Position())
                        {
                            Step = UnloaderReverseStageSteps.S1215_R_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1215_R_POSITION_CHECK:
                    {
                        if (MotorR1.MotionComplete && MotorR2.MotionComplete)
                        {
                            if (IsPositionR1Degree0 && IsPositionR2Degree0)
                            {
                                Step = UnloaderReverseStageSteps.S1220_MOVE_Z_DOWN;
                            }
                            else
                            {
                                Step = UnloaderReverseStageSteps.S1210_MOVE_R_DEG_0;
                            }
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1220_MOVE_Z_DOWN:
                    {
                        if (Move_Z_1_Down_Position() && Move_Z_2_Down_Position())
                        {
                            Step = UnloaderReverseStageSteps.S1225_Z_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1225_Z_POSITION_CHECK:
                    {
                        if (MotorZ1.MotionComplete && MotorZ2.MotionComplete)
                        {
                            if (IsPositionZ1Down && IsPositionZ2Down)
                            {
                                Step = UnloaderReverseStageSteps.S1300_PICK_START;
                            }
                            else
                            {
                                Step = UnloaderReverseStageSteps.S1220_MOVE_Z_DOWN;
                            }
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1300_PICK_START:
                    {
                        if(equipment.after.AoiStage.Stage1.IsExist)
                        {
                            _stage1Step = StageSteps.S1000_PICK_AOI_STAGE_START;
                        }

                        if (equipment.after.AoiStage.Stage2.IsExist)
                        {
                            _stage2Step = StageSteps.S1000_PICK_AOI_STAGE_START;
                        }

                        Step = UnloaderReverseStageSteps.S1310_PICK_WAIT;
                        break;
                    }
                case UnloaderReverseStageSteps.S1310_PICK_WAIT:
                    {
                        if(_stage1Step == StageSteps.S0000_WAIT && _stage2Step == StageSteps.S0000_WAIT)
                        {
                            Step = UnloaderReverseStageSteps.S1999_PICK_AOI_STAGE_END;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S1999_PICK_AOI_STAGE_END:
                    {
                        Tact_Move.Stop();
                        Step = UnloaderReverseStageSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void Seq_Unload()
        {
            switch (Step)
            {
                case UnloaderReverseStageSteps.S2000_PANEL_UNLOAD_START:
                    {
                        Tact_Move.Start();
                        Step = UnloaderReverseStageSteps.S2100_STAY_POSITION_CHECK;
                        break;
                    }
                case UnloaderReverseStageSteps.S2100_STAY_POSITION_CHECK:
                    {
                        if (IsStayPosition)
                        {
                            Step = UnloaderReverseStageSteps.S2230_PANEL_EXIST_CHECK;
                        }
                        else
                        {
                            equipment.after.AoiStage.Stage1.BlowSolOn = true;
                            equipment.after.AoiStage.Stage2.BlowSolOn = true;
                            Step = UnloaderReverseStageSteps.S2110_HANDLER_1_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2110_HANDLER_1_POSITION_CHECK:
                    {
                        double position = equipment.unloader.Handler1.Get_Position_Y_Stay();

                        if (position >= equipment.unloader.Handler1.MotorY.Position || equipment.unloader.Handler1.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
                        {
                            Step = UnloaderReverseStageSteps.S2120_HANDLER_2_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2120_HANDLER_2_POSITION_CHECK:
                    {
                        double position = equipment.after.Handler2.Get_Position_Y_Stay();

                        if (position >= equipment.after.Handler2.MotorY.Position || equipment.after.Handler2.MotorY.Is_Inposition(position, equipment.Setting.Inposition_Offset))
                        {
                            Step = UnloaderReverseStageSteps.S2200_MOVE_Z_UP_POSITION;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2200_MOVE_Z_UP_POSITION:
                    {
                        if(sequenceChangedTime.Seconds < 0.5)
                        {
                            return;
                        }

                        if (Move_Z_1_Up_Position() && Move_Z_2_Up_Position())
                        {
                            Step = UnloaderReverseStageSteps.S2205_Z_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2205_Z_POSITION_CHECK:
                    {
                        if (MotorZ1.MotionComplete && MotorZ2.MotionComplete)
                        {
                            if (IsPositionZ1Up && IsPositionZ2Up)
                            {
                                Step = UnloaderReverseStageSteps.S2210_MOVE_R_DEG_180;
                            }
                            else
                            {
                                Step = UnloaderReverseStageSteps.S2200_MOVE_Z_UP_POSITION;
                            }
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2210_MOVE_R_DEG_180:
                    {
                        if (Move_R_1_Deg_180_Position() && Move_R_2_Deg_180_Position())
                        {
                            Step = UnloaderReverseStageSteps.S2215_R_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2215_R_POSITION_CHECK:
                    {
                        if (MotorR1.MotionComplete && MotorR2.MotionComplete)
                        {
                            if (IsPositionR1Degree180 && IsPositionR2Degree180)
                            {
                                Step = UnloaderReverseStageSteps.S2220_MOVE_Z_DOWN;
                            }
                            else
                            {
                                Step = UnloaderReverseStageSteps.S2210_MOVE_R_DEG_180;
                            }
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2220_MOVE_Z_DOWN:
                    {
                        if (Move_Z_1_Down_Position() && Move_Z_2_Down_Position())
                        {
                            Step = UnloaderReverseStageSteps.S2225_Z_POSITION_CHECK;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2225_Z_POSITION_CHECK:
                    {
                        if (MotorZ1.MotionComplete && MotorZ2.MotionComplete)
                        {
                            if (IsPositionZ1Down && IsPositionZ2Down)
                            {
                                equipment.after.AoiStage.Stage1.BlowSolOn = false;
                                equipment.after.AoiStage.Stage2.BlowSolOn = false;
                                Step = UnloaderReverseStageSteps.S2230_PANEL_EXIST_CHECK;
                            }
                            else
                            {
                                Step = UnloaderReverseStageSteps.S2220_MOVE_Z_DOWN;
                            }
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2230_PANEL_EXIST_CHECK:
                    {
                        if(Stage1.IsExist == false && Stage2.IsExist == false)
                        {
                            Step = UnloaderReverseStageSteps.S2999_PANEL_UNLOAD_END;
                        }
                        break;
                    }
                case UnloaderReverseStageSteps.S2999_PANEL_UNLOAD_END:
                    {
                        Tact_Move.Stop();
                        Step = UnloaderReverseStageSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void Seq_Stage1Step()
        {
            switch(_stage1Step)
            {
                case StageSteps.S1000_PICK_AOI_STAGE_START:
                    {
                        _stage1Step = StageSteps.S1100_VACUUM_ON;
                        break;
                    }
                case StageSteps.S1100_VACUUM_ON:
                    {
                        if (Stage1.IsWorkEnd)
                        {
                            if (Stage1.VacuumSolOn)
                            {
                                _stage1Step = StageSteps.S1110_AOI_STAGE_VACUUM_OFF;
                            }
                            else
                            {
                                Stage1.VacuumOn();
                            }
                        }
                        break;
                    }
                case StageSteps.S1110_AOI_STAGE_VACUUM_OFF:
                    {
                        if (equipment.after.AoiStage.Stage1.IsWorkEnd)
                        {
                            if (equipment.after.AoiStage.Stage1.VacuumSolOn == false)
                            {
                                _stage1Step = StageSteps.S1120_DATA_SET;
                            }
                            else
                            {
                                equipment.after.AoiStage.Stage1.VacuumOff();
                            }
                        }
                        break;
                    }
                case StageSteps.S1120_DATA_SET:
                    {
                        var info = equipment.after.AoiStage.Panel1;
                        info.Uld_Reverse = true;
                        Panel1 = info;
                        equipment.after.AoiStage.Panel1 = new Panel_Info();

                        _stage1Step = StageSteps.S9999_STEP_END;
                        break;
                    }
                case StageSteps.S9000_SCRAP_START:
                    {
                        _stage1Step = StageSteps.S9100_VACUUM_OFF;
                        break;
                    }
                case StageSteps.S9100_VACUUM_OFF:
                    {
                        if (Stage1.IsWorkEnd)
                        {
                            if (Stage1.VacuumSolOn == false)
                            {
                                _stage1Step = StageSteps.S9110_DATA_SET;
                            }
                            else
                            {
                                Stage1.VacuumOff();
                            }
                        }
                        break;
                    }
                case StageSteps.S9110_DATA_SET:
                    {
                        Panel1 = new Panel_Info();
                        _stage1Step = StageSteps.S9999_STEP_END;
                        break;
                    }
                case StageSteps.S9999_STEP_END:
                    {
                        _stage1Step = StageSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void Seq_Stage2Step()
        {
            switch (_stage2Step)
            {
                case StageSteps.S1000_PICK_AOI_STAGE_START:
                    {
                        _stage2Step = StageSteps.S1100_VACUUM_ON;
                        break;
                    }
                case StageSteps.S1100_VACUUM_ON:
                    {
                        if (Stage2.IsWorkEnd)
                        {
                            if (Stage2.VacuumSolOn)
                            {
                                _stage2Step = StageSteps.S1110_AOI_STAGE_VACUUM_OFF;
                            }
                            else
                            {
                                Stage2.VacuumOn();
                            }
                        }
                        break;
                    }
                case StageSteps.S1110_AOI_STAGE_VACUUM_OFF:
                    {
                        if (equipment.after.AoiStage.Stage2.IsWorkEnd)
                        {
                            if (equipment.after.AoiStage.Stage2.VacuumSolOn == false)
                            {
                                _stage2Step = StageSteps.S1120_DATA_SET;
                            }
                            else
                            {
                                equipment.after.AoiStage.Stage2.VacuumOff();
                            }
                        }
                        break;
                    }
                case StageSteps.S1120_DATA_SET:
                    {
                        var info = equipment.after.AoiStage.Panel2;
                        info.Uld_Reverse = true;
                        Panel2 = info;
                        equipment.after.AoiStage.Panel2 = new Panel_Info();

                        _stage2Step = StageSteps.S9999_STEP_END;
                        break;
                    }
                case StageSteps.S9000_SCRAP_START:
                    {
                        _stage2Step = StageSteps.S9100_VACUUM_OFF;
                        break;
                    }
                case StageSteps.S9100_VACUUM_OFF:
                    {
                        if (Stage2.IsWorkEnd)
                        {
                            if (Stage2.VacuumSolOn == false)
                            {
                                _stage2Step = StageSteps.S9110_DATA_SET;
                            }
                            else
                            {
                                Stage2.VacuumOff();
                            }
                        }
                        break;
                    }
                case StageSteps.S9110_DATA_SET:
                    {
                        Panel2 = new Panel_Info();
                        _stage2Step = StageSteps.S9999_STEP_END;
                        break;
                    }
                case StageSteps.S9999_STEP_END:
                    {
                        _stage2Step = StageSteps.S0000_WAIT;
                        break;
                    }
            }
        }
        
        public bool Move_Z_1_Down_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_Z_Down_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_Z_Down_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorZ1.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_Z_1_Up_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_Z_Up_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_Z_Up_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorZ1.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_R_1_Deg_0_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_T_0_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_T_0_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorR1.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_R_1_Deg_180_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_T_180_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_1_T_180_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorR1.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_Z_2_Down_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_Z_Down_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_Z_Down_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorZ2.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_Z_2_Up_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_Z_Up_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_Z_Up_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorZ2.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_R_2_Deg_0_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_T_0_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_T_0_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorR2.Move_Absolute_Pos(position, velocity);
        }

        public bool Move_R_2_Deg_180_Position()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_T_180_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Reverse_Unit_2_T_180_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorR2.Move_Absolute_Pos(position, velocity);
        }
        
        public bool Picker_1_Scrap()
        {
            if (UnitMode == En_Equipment_Mode.Auto || equipment.Auto_Mode)
            {
                Interlock_Manager.Add_Interlock_Msg("Pre_Align_Stage_1 Scrap Can't Start", "Equipment mode is Auto.");
                return false;
            }

            _stage1Step = StageSteps.S9000_SCRAP_START;

            return true;
        }

        public bool Picker_2_Scrap()
        {
            if (UnitMode == En_Equipment_Mode.Auto || equipment.Auto_Mode)
            {
                Interlock_Manager.Add_Interlock_Msg("Pre_Align_Stage_2 Scrap Can't Start", "Equipment mode is Auto.");
                return false;
            }

            _stage2Step = StageSteps.S9000_SCRAP_START;

            return true;
        }
        #endregion
    }
}