using System;

namespace SHARP_CLAS_UI
{
    public class UnloaderLiftOk : Lift
    {
        #region Property
        public bool IsPanelPlaceEnable
        {
            get
            {
                if(IsWorkEnd)
                {
                    if(equipment.UnloaderOkTrayCount > 0)
                    {
                        if(_isCoverTraySet == false)
                        {
                            if (_unloadBit == false)
                            {
                                if (IsPanelFull == false)
                                {
                                    return true;
                                }
                            }
                        }
                    }
                }

                return false;
            }
        }

        public bool is_Tray_Pick_Enable
        {
            get
            {
                if (Step == LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public bool is_Tray_Id_Read_Enable
        {
            get
            {
                if(Step == LiftOutSteps.S1520_TRAY_ID_READ_WAIT && IsBcrReadBit)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public override bool IsPanelEmpty
        {
            get
            {
                int panel_num = 0;
                for (int i = 0; i < equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ng_Row; i++)
                {
                    for (int j = 1; j <= equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ng_Row_Data[i].Column; j++)
                    {
                        panel_num++;

                        var info = Panel_Info_Manager.Instance.Get_Panel_Info(Panel_Info_Names.ULD_Tray_Ok, panel_num);

                        if (info.Blank == false)
                        {
                            return false;
                        }
                    }
                }

                return true;
            }
        }

        public override bool IsPanelFull
        {
            get
            {
                int panel_num = 0;
                for (int i = 0; i < equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Row; i++)
                {
                    for (int j = 1; j <= equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Row_Data[i].Column; j++)
                    {
                        panel_num++;

                        var info = Panel_Info_Manager.Instance.Get_Panel_Info(Panel_Info_Names.ULD_Tray_Ok, panel_num);

                        if (info.Blank)
                        {
                            return false;
                        }
                    }
                }

                return true;
            }
        }

        protected override double UpPosition
        {
            get
            {
                object value;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_Ok_Z_Process_Position, out value);
                var position = double.Parse($"{value}");

                return position;
            }
        }

        public override double TrayInPosition
        {
            get
            {
                if (equipment.Cur_Main_Recipe.tray_info == null)
                    return 0;

                var position = UpPosition - (equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Tray_Pitch * equipment.UnloaderOkTrayCount);
                position = double.Parse(position.ToString("F3"));

                return position;
            }
        }

        public override double TrayWaitPosition
        {
            get
            {
                if (equipment.Cur_Main_Recipe.tray_info == null)
                    return 0;

                var position = UpPosition - (equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Tray_Pitch * (equipment.UnloaderOkTrayCount + 1));
                position = double.Parse(position.ToString("F3"));

                return position;
            }
        }

        public override string TrayID
        {
            get
            {
                object value;
                equipment.sm.Get_Value(Process_Memory_Address.ULD_Tray_Ok_ID, out value);

                return value.ToString();
            }

            set
            {
                equipment.sm.Set_Value(Process_Memory_Address.ULD_Tray_Ok_ID, value);
            }
        }

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

        public override bool IsStayPosition
        {
            get
            {
                object value;

                equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_Ok_Z_Wait_Position, out value);
                var position = double.Parse($"{value}");

                return MotorZ.Is_Inposition(position, equipment.Setting.Inposition_Offset);
            }
        }

        public LiftOutSteps Step
        {
            get
            {
                return _step;
            }

            set
            {
                _step = value;
            }
        }
        #endregion

        #region Field
        private LiftOutSteps _step;
        private LiftOutSteps _oldStep;

        public LiftHomeSteps _homeStep;
        
        bool _isCoverTraySet;
        bool _unloadBit;
        #endregion

        #region Construct
        public UnloaderLiftOk(Equipment equipment) : base(equipment, MotorAxis.ULD_Tray_OK_Lift_Z, "UnloaderLiftOk")
        {
            Step = LiftOutSteps.S0000_WAIT;
            _oldStep = LiftOutSteps.S0000_WAIT;

            Initialize(InputData.ULD_Ok_Out_Lift_Up_1_1_Sensor, InputData.ULD_Ok_Out_Lift_Up_1_2_Sensor, InputData.ULD_Ok_Out_Lift_Up_2_1_Sensor, InputData.ULD_Ok_Out_Lift_Up_2_2_Sensor);

            pauseDisableList.Add(LiftOutSteps.S1415_LIFT_PITCH_DOWN_CHECK);
            pauseDisableList.Add(LiftOutSteps.S1425_LIFT_PITCH_UP_CHECK);
            pauseDisableList.Add(LiftOutSteps.S1435_LIFT_PITCH_LAST_UP_CHECK);
            pauseDisableList.Add(LiftOutSteps.S2405_LIFT_DOWN_CHECK);

            AlignerTop.Initialize(OutputData.ULD_Ok_Out_Align_Top_Sol_Valve, InputData.ULD_Ok_Out_Align_Top_1_Fwd_Sensor, InputData.ULD_Ok_Out_Align_Top_2_Fwd_Sensor, InputData.ULD_Ok_Out_Align_Top_1_Bwd_Sensor, InputData.ULD_Ok_Out_Align_Top_2_Bwd_Sensor, En_Alarm_List.AL_0757_ULD_TRAY_OK_ALIGN_TOP_1_FWD_SENSOR_CHECK, En_Alarm_List.AL_0758_ULD_TRAY_OK_ALIGN_TOP_2_FWD_SENSOR_CHECK, En_Alarm_List.AL_0759_ULD_TRAY_OK_ALIGN_TOP_1_BWD_SENSOR_CHECK, En_Alarm_List.AL_0760_ULD_TRAY_OK_ALIGN_TOP_2_BWD_SENSOR_CHECK);
            Clamper.Initialize(OutputData.ULD_Ok_Out_Clamp_Sol_Valve, InputData.ULD_Ok_Out_Clamp_1_Clamp_Sensor, InputData.ULD_Ok_Out_Clamp_2_Clamp_Sensor, InputData.ULD_Ok_Out_Clamp_1_Unclamp_Sensor, InputData.ULD_Ok_Out_Clamp_2_Unclamp_Sensor, En_Alarm_List.AL_0761_ULD_TRAY_OK_CLAMP_1_SENSOR_CHECK, En_Alarm_List.AL_0762_ULD_TRAY_OK_CLAMP_2_SENSOR_CHECK, En_Alarm_List.AL_0763_ULD_TRAY_OK_UNCLAMP_1_SENSOR_CHECK, En_Alarm_List.AL_0764_ULD_TRAY_OK_UNCLAMP_2_SENSOR_CHECK);
            Stacker.Initialize(OutputData.ULD_Ok_Out_Stacker_Sol_Valve, InputData.ULD_Ok_Out_Stacker_1_Fwd_Sensor, InputData.ULD_Ok_Out_Stacker_2_Fwd_Sensor, InputData.ULD_Ok_Out_Stacker_3_Fwd_Sensor, InputData.ULD_Ok_Out_Stacker_4_Fwd_Sensor, InputData.ULD_Ok_Out_Stacker_1_Bwd_Sensor, InputData.ULD_Ok_Out_Stacker_2_Bwd_Sensor, InputData.ULD_Ok_Out_Stacker_3_Bwd_Sensor, InputData.ULD_Ok_Out_Stacker_4_Bwd_Sensor, En_Alarm_List.AL_0765_ULD_TRAY_OK_STACKER_1_FWD_SENSOR_CHECK, En_Alarm_List.AL_0766_ULD_TRAY_OK_STACKER_2_FWD_SENSOR_CHECK, En_Alarm_List.AL_0767_ULD_TRAY_OK_STACKER_3_FWD_SENSOR_CHECK, En_Alarm_List.AL_0768_ULD_TRAY_OK_STACKER_4_FWD_SENSOR_CHECK, En_Alarm_List.AL_0769_ULD_TRAY_OK_STACKER_1_BWD_SENSOR_CHECK, En_Alarm_List.AL_0770_ULD_TRAY_OK_STACKER_2_BWD_SENSOR_CHECK, En_Alarm_List.AL_0771_ULD_TRAY_OK_STACKER_3_BWD_SENSOR_CHECK, En_Alarm_List.AL_0772_ULD_TRAY_OK_STACKER_4_BWD_SENSOR_CHECK);

            MotorZ.Check_Jog_Interlock = Jog_Interlock;
            MotorZ.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 < LiftOutSteps.S2000_TRAY_UNLOADING_START || LiftOutSteps.S2999_TRAY_UNLOADING_END < Step)
                Step = LiftOutSteps.S0000_WAIT;

            _homeStep = LiftHomeSteps.S0000_WAIT;
        }

        public void ExecuteAuto()
        {
            if (IsWorkEnd)
            {
                if (_isCoverTraySet)
                {
                    Step = LiftOutSteps.S2000_TRAY_UNLOADING_START;
                }
                else
                {
                    if (equipment.UnloaderOkTrayCount <= equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Tray_Count)
                    {
                        if (IsPanelFull || _unloadBit || equipment.UnloaderOkTrayCount == 0)
                        {
                            Step = LiftOutSteps.S1000_LIFT_MOVE_START;
                        }
                    }
                }
            }
        }

        public override void MonitoringStatus()
        {
            if (equipment.User.Level != En_User_Level.Master && equipment.Door_Opened)
            {
                if (MotorZ.MotionComplete == false)
                {
                    MotorZ.Move_Stop();
                }
            }
        }

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

            AlignerTop.ExecuteProcess();
            Clamper.ExecuteProcess();
            Stacker.ExecuteProcess();

            if (UnitMode != En_Equipment_Mode.Home)
            {
                UnloadingTray();
            }

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

                LoadingTray();
            }
        }

        public void ExecuteHome()
        {
            switch(_homeStep)
            {
                case LiftHomeSteps.S0000_WAIT:
                    {
                        _homeStep = LiftHomeSteps.S1000_STATUS_CHECK;
                        break;
                    }
                case LiftHomeSteps.S1000_STATUS_CHECK:
                    {
                        if (MotorZ.ErrorStop)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0451_ULD_TRAY_OK_LIFT_Z_ERROR_STOP);
                        }
                        else if (!MotorZ.PowerOn)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0450_ULD_TRAY_OK_LIFT_Z_POWER_OFF);
                        }
                        else
                        {
                            _homeStep = LiftHomeSteps.S1100_CONVEYOR_HOME_CHECK;
                        }
                        break;
                    }
                case LiftHomeSteps.S1100_CONVEYOR_HOME_CHECK:
                    {
                        if (equipment.unloader.ConveyorOut.IsHomeComplete)
                        {
                            _homeStep = LiftHomeSteps.S1110_CONVEYOR_LIFT_SENSOR_CHECK;
                        }
                        break;
                    }
                case LiftHomeSteps.S1110_CONVEYOR_LIFT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.ConveyorOut.IsLiftInSensor || equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                        {
                            if (equipment.unloader.ConveyorOut.IsLiftInSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Home can't run.", "Lift in sensor is detected.");
                            }

                            if (equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Home can't run.", "Lift in complete sensor is detected.");
                            }
                        }
                        else
                        {
                            _homeStep = LiftHomeSteps.S1200_MOTOR_Z_HOME;
                        }

                        break;
                    }
                case LiftHomeSteps.S1200_MOTOR_Z_HOME:
                    {
                        if (MotorZ.Home())
                        {
                            homeCheckedTime.Restart();
                            _homeStep = LiftHomeSteps.S1205_MOTOR_Z_HOME_CHECK;
                        }
                        break;
                    }
                case LiftHomeSteps.S1205_MOTOR_Z_HOME_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (!MotorZ.IsHomed)
                        {
                            if (MotorZ.Homing == false && MotorZ.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0451_ULD_TRAY_OK_LIFT_Z_ERROR_STOP);
                            }
                        }
                        else
                        {
                            _homeStep = LiftHomeSteps.S1300_MOVE_STAY_POSITION;
                        }
                        break;
                    }
                case LiftHomeSteps.S1300_MOVE_STAY_POSITION:
                    {
                        if (MoveStayPosition())
                        {
                            homeCheckedTime.Restart();
                            _homeStep = LiftHomeSteps.S1305_POSITION_CHECK;
                        }
                        break;
                    }
                case LiftHomeSteps.S1305_POSITION_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (MotorZ.ErrorStop)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0451_ULD_TRAY_OK_LIFT_Z_ERROR_STOP);
                        }
                        else if (MotorZ.MotionComplete)
                        {
                            if (IsStayPosition)
                            {
                                _homeStep = LiftHomeSteps.S9999_END;
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Home can't run.", $"Lift is not wait position.");
                                _homeStep = LiftHomeSteps.S1300_MOVE_STAY_POSITION;
                            }
                        }
                        break;
                    }
                case LiftHomeSteps.S9999_END:
                    {
                        isHomeComplete = true;
                        _homeStep = LiftHomeSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        private void LoadingTray()
        {
            switch(Step)
            {
                case LiftOutSteps.S1000_LIFT_MOVE_START:
                    {
                        Step = LiftOutSteps.S1100_CONVEYOR_LIFT_SENSOR_CHECK;
                        break;
                    }
                case LiftOutSteps.S1100_CONVEYOR_LIFT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.ConveyorOut.IsLiftInSensor || equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                        {
                            if (equipment.unloader.ConveyorOut.IsLiftInSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0742_ULD_TRAY_OK_CONVEYOR_LIFT_IN_SENSOR_CHECK);
                            }

                            if (equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0743_ULD_TRAY_OK_CONVEYOR_LIFT_IN_COMPLETE_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = LiftOutSteps.S1110_TRAY_TRANSTER_POSITION_STAY_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1110_TRAY_TRANSTER_POSITION_STAY_CHECK:
                    {
                        Step = LiftOutSteps.S1200_ALIGN_TOP_BACKWARD;
                        break;
                    }
                case LiftOutSteps.S1200_ALIGN_TOP_BACKWARD:
                    {
                        if (AlignerTop.IsWorkEnd)
                        {
                            if (AlignerTop.IsBackward)
                            {
                                Step = LiftOutSteps.S1210_STACKER_BACKWARD;
                            }
                            else
                            {
                                AlignerTop.Backward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1210_STACKER_BACKWARD:
                    {
                        if (Stacker.IsWorkEnd)
                        {
                            if (Stacker.IsBackward)
                            {
                                Step = LiftOutSteps.S1220_UNCLAMP;
                            }
                            else
                            {
                                Stacker.Backward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1220_UNCLAMP:
                    {
                        if (Clamper.IsWorkEnd)
                        {
                            if (Clamper.IsUnclamp)
                            {
                                Step = LiftOutSteps.S1300_LIFT_MOVE;
                            }
                            else
                            {
                                Clamper.Unclamp();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1300_LIFT_MOVE:
                    {
                        if (MoveTrayInPosition(TrayWaitPosition))
                        {
                            Step = LiftOutSteps.S1305_LIFT_MOVE_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1305_LIFT_MOVE_CHECK:
                    {
                        if (sequenceChangedTime.Seconds < 0.5) return;

                        if (IsLiftLimitSensor1 || IsLiftLimitSensor2)
                        {
                            if (IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0753_ULD_TRAY_OK_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0754_ULD_TRAY_OK_LIFT_UP_1_2_SENSOR_CHECK);
                            }

                            //Step = LiftOutSteps.S1440_TRAY_SCRAP_CHECK;

                            return;
                        }

                        if (MotorZ.MotionComplete)
                        {
                            if (MotorZ.Is_Inposition(TrayWaitPosition, equipment.Setting.Inposition_Offset))
                            {
                                if (IsLiftInSensor1 || IsLiftInSensor2)
                                {
                                    if (IsLiftInSensor1)
                                    {
                                        Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0755_ULD_TRAY_OK_LIFT_UP_2_1_SENSOR_CHECK);
                                    }

                                    if (IsLiftInSensor2)
                                    {
                                        Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0756_ULD_TRAY_OK_LIFT_UP_2_2_SENSOR_CHECK);
                                    }
                                }
                                else
                                {
                                    Step = LiftOutSteps.S1310_ALIGN_TOP_FORWARD;
                                }
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Loading can't run.", $"Lift is not down position({TrayWaitPosition}).");
                                Step = LiftOutSteps.S1300_LIFT_MOVE;
                            }
                        }
                        break;
                    }

                case LiftOutSteps.S1310_ALIGN_TOP_FORWARD:
                    {
                        if (AlignerTop.IsWorkEnd)
                        {
                            if (AlignerTop.IsForward)
                            {
                                Step = LiftOutSteps.S1320_CLAMP;
                            }
                            else
                            {
                                AlignerTop.Forward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1320_CLAMP:
                    {
                        if (Clamper.IsWorkEnd)
                        {
                            if (Clamper.IsClamp)
                            {
                                Step = LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT;
                            }
                            else
                            {
                                Clamper.Clamp();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT:
                    {
                        if (equipment.UnloaderOkTrayCount != _trayCount)
                        {
                            if (equipment.UnloaderOkTrayCount == 1)
                            {
                                IsFirstTray = true;
                            }

                            _pitchPosition = 0;

                            if (IsLiftInSensor1 && IsLiftInSensor2)
                            {
                                Step = LiftOutSteps.S1410_LIFT_PITCH_DOWN;
                            }
                            else
                            {
                                Step = LiftOutSteps.S1420_LIFT_PITCH_UP;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1410_LIFT_PITCH_DOWN:
                    {
                        if (Math.Abs(_pitchPosition) > equipment.Setting.Tray_Alarm_Range)
                        {
                            _pitchPosition = 0;
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0952_ULD_TRAY_OK_PITCH_RANGE_ALARM);

                            //Step = LiftOutSteps.S1440_TRAY_SCRAP_CHECK;
                        }
                        else
                        {
                            _pitchPosition -= equipment.Setting.Tray_Move_Pitch;

                            MoveTrayInPosition(TrayInPosition + _pitchPosition);
                            Step = LiftOutSteps.S1415_LIFT_PITCH_DOWN_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1415_LIFT_PITCH_DOWN_CHECK:
                    {
                        if (sequenceChangedTime.Seconds < 0.5) return;

                        if (MotorZ.MotionComplete)
                        {
                            if (MotorZ.Is_Inposition(TrayInPosition + _pitchPosition, equipment.Setting.Inposition_Offset))
                            {
                                if (IsLiftInSensor1 && IsLiftInSensor2)
                                {
                                    Step = LiftOutSteps.S1410_LIFT_PITCH_DOWN;
                                }
                                else
                                {
                                    Step = LiftOutSteps.S1420_LIFT_PITCH_UP;
                                }
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Down can't run.", $"ULD Tray OK Lift is not down position({TrayInPosition + _pitchPosition}).");
                                Step = LiftOutSteps.S1410_LIFT_PITCH_DOWN;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1420_LIFT_PITCH_UP:
                    {
                        if (Math.Abs(_pitchPosition) > equipment.Setting.Tray_Alarm_Range)
                        {
                            _pitchPosition = 0;
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0952_ULD_TRAY_OK_PITCH_RANGE_ALARM);

                            //Step = LiftOutSteps.S1440_TRAY_SCRAP_CHECK;
                        }
                        else
                        {
                            _pitchPosition += equipment.Setting.Tray_Move_Pitch;

                            MoveTrayInPosition(TrayInPosition + _pitchPosition);
                            Step = LiftOutSteps.S1425_LIFT_PITCH_UP_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1425_LIFT_PITCH_UP_CHECK:
                    {
                        if (sequenceChangedTime.Seconds < 0.5) return;

                        if (IsLiftLimitSensor1 || IsLiftLimitSensor2)
                        {
                            if (MotorZ.Move_Stop())
                            {
                                _pitchPosition = 0;

                                if (IsLiftLimitSensor1)
                                {
                                    Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0753_ULD_TRAY_OK_LIFT_UP_1_1_SENSOR_CHECK);
                                }

                                if (IsLiftLimitSensor2)
                                {
                                    Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0754_ULD_TRAY_OK_LIFT_UP_1_2_SENSOR_CHECK);
                                }

                                //Step = LiftOutSteps.S1440_TRAY_SCRAP_CHECK;
                                return;
                            }
                        }

                        if (MotorZ.MotionComplete)
                        {
                            if (MotorZ.Is_Inposition(TrayInPosition + _pitchPosition, equipment.Setting.Inposition_Offset))
                            {
                                if (IsLiftInSensor1 && IsLiftInSensor2)
                                {
                                    Step = LiftOutSteps.S1430_LIFT_PITCH_LAST_UP;
                                }
                                else
                                {
                                    Step = LiftOutSteps.S1420_LIFT_PITCH_UP;
                                }
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Down can't run.", $"ULD Tray OK Lift is not down position({TrayInPosition + _pitchPosition}).");
                                Step = LiftOutSteps.S1420_LIFT_PITCH_UP;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1430_LIFT_PITCH_LAST_UP:
                    {
                        _pitchPosition += equipment.Setting.ULD_Ok_Tray_Move_Last_Pitch;

                        MoveTrayInPosition(TrayInPosition + _pitchPosition);
                        Step = LiftOutSteps.S1435_LIFT_PITCH_LAST_UP_CHECK;
                        break;
                    }
                case LiftOutSteps.S1435_LIFT_PITCH_LAST_UP_CHECK:
                    {
                        if (sequenceChangedTime.Seconds < 0.5) return;

                        if (MotorZ.MotionComplete)
                        {
                            if (MotorZ.Is_Inposition(TrayInPosition + _pitchPosition, equipment.Setting.Inposition_Offset))
                            {
                                if (IsLiftInSensor1 && IsLiftInSensor2)
                                {
                                    _trayCount = equipment.UnloaderOkTrayCount;
                                    Step = LiftOutSteps.S1500_CLAMP;
                                }
                                else
                                {
                                    if (IsLiftInSensor1 == false)
                                    {
                                        Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0565_LD_TRAY_IN_LIFT_UP_2_1_SENSOR_CHECK);
                                    }

                                    if (IsLiftInSensor2 == false)
                                    {
                                        Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0566_LD_TRAY_IN_LIFT_UP_2_2_SENSOR_CHECK);
                                    }

                                    _pitchPosition = 0;
                                    //Step = LiftOutSteps.S1440_TRAY_SCRAP_CHECK;
                                }
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Down can't run.", $"ULD Tray OK Lift is not down position({TrayInPosition + _pitchPosition}).");
                                Step = LiftOutSteps.S1430_LIFT_PITCH_LAST_UP;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1440_TRAY_SCRAP_CHECK:
                    {
                        var scrap = true;

                        if (scrap)
                        {
                            equipment.UnloaderOkTrayCount = equipment.UnloaderOkTrayCount - 1;
                            Step = LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT;
                        }
                        else
                        {
                            if (IsLiftInSensor1 && IsLiftInSensor2)
                            {
                                Step = LiftOutSteps.S1410_LIFT_PITCH_DOWN;
                            }
                            else
                            {
                                Step = LiftOutSteps.S1420_LIFT_PITCH_UP;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1500_CLAMP:
                    {
                        if (Clamper.IsWorkEnd)
                        {
                            if (Clamper.IsClamp)
                            {
                                Step = LiftOutSteps.S1510_ALIGN_TOP_FORWARD;
                            }
                            else
                            {
                                Clamper.Clamp();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1510_ALIGN_TOP_FORWARD:
                    {
                        if (AlignerTop.IsWorkEnd)
                        {
                            if (AlignerTop.IsForward)
                            {
                                IsBcrReadBit = true;

                                Step = LiftOutSteps.S1520_TRAY_ID_READ_WAIT;
                            }
                            else
                            {
                                AlignerTop.Forward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1520_TRAY_ID_READ_WAIT:
                    {
                        if (IsBcrReadBit == false)
                        {
                            if (equipment.UnloaderOkTrayCount != _trayCount)
                            {
                                Step = LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT;
                            }
                            else
                            {
                                if (SetTrayID(TrayID))
                                {

                                    Step = LiftOutSteps.S1600_TRAY_PANEL_DATA_SET;
                                }
                            }
                        }

                        break;
                    }
                case LiftOutSteps.S1600_TRAY_PANEL_DATA_SET:
                    {
                        if (SetPanelInfo(true))
                        {
                            if (_unloadBit || _trayCount > equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Tray_Count)
                            {
                                _isCoverTraySet = true;
                            }

                            Step = LiftOutSteps.S1605_TRAY_PANEL_DATA_SET_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1605_TRAY_PANEL_DATA_SET_CHECK:
                    {
                        if (IsPanelEmpty)
                        {
                            if (equipment.cim_mode == En_Cim_Mode.Online)
                            {
                                //if (IsFirstTray)
                                //{
                                //    IsFirstTray = false;
                                //    Step = LiftOutSteps.S1610_PORT_STATUS_CIM_SEND;
                                //}
                                //else
                                //{
                                //    Step = LiftOutSteps.S1620_PANEL_IN_DATA_CIM_SEND;
                                //}
                                if (IsFirstTray)
                                {
                                    IsFirstTray = false;
                                }

                                Step = LiftOutSteps.S1620_PANEL_IN_DATA_CIM_SEND;
                            }
                            else
                            {
                                if (IsFirstTray)
                                {
                                    IsFirstTray = false;
                                }

                                Step = LiftOutSteps.S1999_LIFT_MOVE_END;
                            }
                        }
                        else
                        {
                            Step = LiftOutSteps.S1600_TRAY_PANEL_DATA_SET;
                        }
                        break;
                    }
                case LiftOutSteps.S1610_PORT_STATUS_CIM_SEND:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S1999_LIFT_MOVE_END;
                            return;
                        }

                        if (equipment.cim_client.Send_Port_Status("E12345678", En_Port_ID.P03, En_Tray_Code.P, false, En_Port_Status.CMP, TrayID))
                        {
                            Step = LiftOutSteps.S1615_PORT_STATUS_CIM_SEND_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1615_PORT_STATUS_CIM_SEND_CHECK:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S1999_LIFT_MOVE_END;
                            return;
                        }

                        if (equipment.cim_client.Get_Command_Ack(En_Cim_Command.PTSTR))
                        {
                            if (equipment.cim_client.Get_Command_Result(En_Cim_Command.PTSTR))
                            {
                                Step = LiftOutSteps.S1620_PANEL_IN_DATA_CIM_SEND;
                            }
                            else
                            {
                                Step = LiftOutSteps.S1610_PORT_STATUS_CIM_SEND;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1620_PANEL_IN_DATA_CIM_SEND:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S1999_LIFT_MOVE_END;
                            return;
                        }
                        
                        if (!equipment.cim_client.Send_Panel_Tray_In("E123456", TrayID, "", "", En_Port_ID.P03))
                        {
                            Step = LiftOutSteps.S1625_PANEL_IN_DATA_CIM_SEND_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S1625_PANEL_IN_DATA_CIM_SEND_CHECK:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S1999_LIFT_MOVE_END;
                            return;
                        }

                        if (equipment.cim_client.Get_Command_Ack(En_Cim_Command.PTINR))
                        {
                            if (equipment.cim_client.Get_Command_Result(En_Cim_Command.PTINR))
                            {
                                Step = LiftOutSteps.S1999_LIFT_MOVE_END;
                            }
                            else
                            {
                                Step = LiftOutSteps.S1620_PANEL_IN_DATA_CIM_SEND;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S1999_LIFT_MOVE_END:
                    {
                        Step = LiftOutSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        private void UnloadingTray()
        {
            switch (Step)
            {
                case LiftOutSteps.S2000_TRAY_UNLOADING_START:
                    {
                        if (equipment.cim_mode == En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2100_PANEL_REPORT_CIM_SEND;
                        }
                        else
                        {
                            Step = LiftOutSteps.S2200_UNCLAMP;
                        }
                        break;
                    }
                case LiftOutSteps.S2100_PANEL_REPORT_CIM_SEND:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2200_UNCLAMP;
                            return;
                        }

                        if (equipment.cim_client.Send_Panel_Form_Report("E12345678", TrayID, En_Port_ID.P03))
                        {
                            Step = LiftOutSteps.S2105_PANEL_REPORT_CIM_SEND_WAIT;
                        }
                        break;
                    }
                case LiftOutSteps.S2105_PANEL_REPORT_CIM_SEND_WAIT:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2200_UNCLAMP;
                            return;
                        }

                        if (equipment.cim_client.Get_Command_Ack(En_Cim_Command.PCMRT))
                        {
                            if (equipment.cim_client.Get_Command_Result(En_Cim_Command.PCMRT))
                            {
                                Step = LiftOutSteps.S2110_PORT_STATUS_CIM_SEND;
                            }
                            else
                            {
                                Step = LiftOutSteps.S2100_PANEL_REPORT_CIM_SEND;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2110_PORT_STATUS_CIM_SEND:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2200_UNCLAMP;
                            return;
                        }
                        
                        if (equipment.cim_client.Send_Port_Status("E12345678", En_Port_ID.P03, En_Tray_Code.P, false, En_Port_Status.CMP, TrayID))
                        {
                            Step = LiftOutSteps.S2115_PORT_STATUS_CIM_SEND_WAIT;
                        }
                        break;
                    }
                case LiftOutSteps.S2115_PORT_STATUS_CIM_SEND_WAIT:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2200_UNCLAMP;
                            return;
                        }

                        if (equipment.cim_client.Get_Command_Ack(En_Cim_Command.PTSTR))
                        {
                            if (equipment.cim_client.Get_Command_Result(En_Cim_Command.PTSTR))
                            {
                                Step = LiftOutSteps.S2200_UNCLAMP;
                            }
                            else
                            {
                                Step = LiftOutSteps.S2110_PORT_STATUS_CIM_SEND;
                            }
                        }

                        break;
                    }
                case LiftOutSteps.S2200_UNCLAMP:
                    {
                        if (Clamper.IsWorkEnd)
                        {
                            if (Clamper.IsUnclamp)
                            {
                                Step = LiftOutSteps.S2210_STACKER_BACKWARD;
                            }
                            else
                            {
                                Clamper.Unclamp();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2210_STACKER_BACKWARD:
                    {
                        if (Stacker.IsWorkEnd)
                        {
                            if (Stacker.IsBackward)
                            {
                                Step = LiftOutSteps.S2220_ALIGN_TOP_BACKWARD;
                            }
                            else
                            {
                                Stacker.Backward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2220_ALIGN_TOP_BACKWARD:
                    {
                        if (AlignerTop.IsWorkEnd)
                        {
                            if (AlignerTop.IsBackward)
                            {
                                Step = LiftOutSteps.S2300_CONVEYOR_LIFT_SENSOR_CHECK;
                            }
                            else
                            {
                                AlignerTop.Backward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2300_CONVEYOR_LIFT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.ConveyorOut.IsLiftInSensor || equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                        {
                            if (equipment.unloader.ConveyorOut.IsLiftInSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0742_ULD_TRAY_OK_CONVEYOR_LIFT_IN_SENSOR_CHECK);
                            }

                            if (equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0743_ULD_TRAY_OK_CONVEYOR_LIFT_IN_COMPLETE_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = LiftOutSteps.S2310_ALIGN_Y_FORWARD;
                        }
                        break;
                    }
                case LiftOutSteps.S2310_ALIGN_Y_FORWARD:
                    {
                        if (equipment.unloader.ConveyorOut.AlignerY.IsWorkEnd)
                        {
                            if (equipment.unloader.ConveyorOut.AlignerY.IsForward)
                            {
                                Step = LiftOutSteps.S2320_ALIGN_X_BACKWARD;
                            }
                            else
                            {
                                equipment.unloader.ConveyorOut.AlignerY.Forward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2320_ALIGN_X_BACKWARD:
                    {
                        if (equipment.unloader.ConveyorOut.AlignerX.IsWorkEnd)
                        {
                            if (equipment.unloader.ConveyorOut.AlignerX.IsBackward)
                            {
                                Step = LiftOutSteps.S2400_LIFT_DOWN;
                            }
                            else
                            {
                                equipment.unloader.ConveyorOut.AlignerX.Backward();
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2400_LIFT_DOWN:
                    {
                        if (equipment.unloader.ConveyorOut.IsLiftInSensor || equipment.unloader.ConveyorOut.IsLiftInCompleteSensor || !equipment.unloader.ConveyorOut.MotorX.MotionComplete)
                        {
                            if (equipment.unloader.ConveyorOut.IsLiftInSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray Ok Lift Unloading can't run.", "Lift in sensor is detected.");
                            }

                            if (equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray Ok Lift Unloading can't run.", "Lift in Complete sensor is detected.");
                            }

                            if (!equipment.unloader.ConveyorOut.MotorX.MotionComplete)
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray Ok Lift Unloading can't run.", "ULD Ok Conveyor status is moving.");
                            }
                        }
                        else
                        {
                            if (MoveStayPosition())
                            {
                                sequenceChangedTime.Start();
                                Step = LiftOutSteps.S2405_LIFT_DOWN_CHECK;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2405_LIFT_DOWN_CHECK:
                    {
                        if (sequenceChangedTime.Seconds < 0.5) return;
                        
                        if (MotorZ.MotionComplete)
                        {
                            if (IsStayPosition)
                            {
                                if (equipment.unloader.ConveyorOut.IsLiftInSensor || equipment.unloader.ConveyorOut.IsLiftInCompleteSensor)
                                {
                                    Step = LiftOutSteps.S2420_CONVEYOR_UNLOAD;
                                }
                                else
                                {
                                    Step = LiftOutSteps.S2500_PORT_STATUS_CIM_SEND;
                                }
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray OK Lift Unloading can't run.", "Position is not wait.");
                                Step = LiftOutSteps.S2400_LIFT_DOWN;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2420_CONVEYOR_UNLOAD:
                    {
                        equipment.unloader.ConveyorOut.Unload();
                        Step = LiftOutSteps.S2425_CONVEYOR_UNLOAD_CHECK;
                        break;
                    }
                case LiftOutSteps.S2425_CONVEYOR_UNLOAD_CHECK:
                    {
                        if (equipment.unloader.ConveyorOut.Step == ConveyorOutSteps.S0000_WAIT)
                        {
                            _trayCount = 0;
                            if (equipment.cim_mode == En_Cim_Mode.Online)
                            {
                                Step = LiftOutSteps.S2500_PORT_STATUS_CIM_SEND;
                            }
                            else
                            {
                                Step = LiftOutSteps.S2999_TRAY_UNLOADING_END;
                            }
                        }
                        break;
                    }
                case LiftOutSteps.S2500_PORT_STATUS_CIM_SEND:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2999_TRAY_UNLOADING_END;
                            return;
                        }

                        if (equipment.cim_client.Send_Port_Status("E12345678", En_Port_ID.P03, En_Tray_Code.P, false, En_Port_Status.EMP))
                        {
                            Step = LiftOutSteps.S2505_PORT_STATUS_CIM_SEND_CHECK;
                        }
                        break;
                    }
                case LiftOutSteps.S2505_PORT_STATUS_CIM_SEND_CHECK:
                    {
                        if (equipment.cim_mode != En_Cim_Mode.Online)
                        {
                            Step = LiftOutSteps.S2999_TRAY_UNLOADING_END;
                            return;
                        }

                        if (equipment.cim_client.Get_Command_Ack(En_Cim_Command.PTSTR))
                        {
                            if (equipment.cim_client.Get_Command_Result(En_Cim_Command.PTSTR))
                            {
                                Step = LiftOutSteps.S2999_TRAY_UNLOADING_END;
                            }
                            else
                            {
                                Step = LiftOutSteps.S2500_PORT_STATUS_CIM_SEND;
                            }
                        }

                        break;
                    }
                case LiftOutSteps.S2999_TRAY_UNLOADING_END:
                    {
                        _unloadBit = false;
                        _isCoverTraySet = false;
                        equipment.Set_Unload_Tray_Buzzer(true);
                        equipment.UnloaderOkTrayCount = 0;
                        Step = LiftOutSteps.S0000_WAIT;
                        break;
                    }
            }
        }
        
        public bool SetPanelInfo(bool blank)
        {
            if (equipment.Cur_Main_Recipe.tray_info== null) return false;

            bool check = true;
            int row = equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Row;
            int panel_num = 0;
            Panel_Info panel = new Panel_Info();
            panel.Blank = blank;

            for (int i = 0; i < row; i++)
            {
                for (int j = 1; j <= equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Row_Data[i].Column; j++)
                {
                    panel_num++;
                    
                    panel.Tray_Num = (equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Tray_Count - equipment.UnloaderOkTrayCount) + 1;
                    panel.Panel_Num = panel_num;
                    panel.Row_Num = i + 1;
                    panel.Column_Num = j;

                    check &= Panel_Info_Manager.Instance.Set_Panel_Info(Panel_Info_Names.ULD_Tray_Ok, panel);
                }
            }

            return check;
        }

        public bool SetTrayID(string tray_id)
        {
            if (equipment.Cur_Main_Recipe.tray_info == null) return false;

            bool check = true;
            int row = equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Row;
            int panel_num = 0;

            for (int i = 0; i < row; i++)
            {
                for (int j = 1; j <= equipment.Cur_Main_Recipe.tray_info.ULD_Tray_Ok_Row_Data[i].Column; j++)
                {
                    panel_num++;
                    Panel_Info panel = Panel_Info_Manager.Instance.Get_Panel_Info(Panel_Info_Names.ULD_Tray_Ok, panel_num);

                    panel.Tray_ID = tray_id;

                    check &= Panel_Info_Manager.Instance.Set_Panel_Info(Panel_Info_Names.ULD_Tray_Ok, panel);
                }
            }

            return check;
        }

        public bool MoveStayPosition()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_Ok_Z_Wait_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_Ok_Z_Wait_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorZ.Move_Absolute_Pos(position, velocity);
        }

        public bool MoveTrayInPosition(double position)
        {
            object value;
            double velocity;

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

            return MotorZ.Move_Absolute_Pos(position, velocity);
        }
        
        public bool Tray_Out()
        {
            if (UnitMode == En_Equipment_Mode.Stop)
            {
                Step = LiftOutSteps.S2000_TRAY_UNLOADING_START;
                return true;
            }
            else
                return false;
        }

        public void Unload_tray_set()
        {
            _unloadBit = true;
            SetPanelInfo(false);
        }
        #endregion
    }
}