using System;

namespace SHARP_CLAS_UI
{
    public class UnloaderTrayTransfer : TrayTransfer
    {
        #region Enum
        #endregion

        #region Property
        public bool is_Tray_Pick_Enable
        {
            get
            {
                if (Step != TrayTransferSteps.S0000_WAIT) return false;

                if (!IsStayPosition) return false;

                if (Get_Vacuum_Check()) return false;

                return true;
            }
        }

        public bool is_Tray_Place_Enable
        {
            get
            {
                if (Step != TrayTransferSteps.S0000_WAIT) return false;

                if (!IsStayPosition) return false;

                if (!Get_Vacuum_Check()) return false;

                return true;
            }
        }
        
        public TrayTransferSteps Step
        {
            get
            {
                return _step;
            }

            set
            {
                _step = value;
            }
        }

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

        public override bool IsStayPosition
        {
            get
            {
                object value;

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

                return MotorX.Is_Inposition(position, equipment.Setting.Inposition_Offset);
            }
        }
        
        public bool isLiftNgPosition
        {
            get
            {
                object value;

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

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

        public bool isLiftOkPosition
        {
            get
            {
                object value;

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

                return MotorX.Is_Inposition(position, equipment.Setting.Inposition_Offset);
            }
        }
        #endregion

        #region Field
        private TrayTransferSteps _step;
        private TrayTransferSteps _oldStep;
        private TrayTransferHomeSteps _homeStep;

        private SequenceTimer _tactTime = new SequenceTimer();
        #endregion

        #region Construct 
        public UnloaderTrayTransfer(Equipment equipment) : base(equipment, MotorAxis.ULD_Tray_TR_X, "UnloaderTrayTransfer")
        {
            Step = TrayTransferSteps.S0000_WAIT;
            _oldStep = TrayTransferSteps.S0000_WAIT;

            Picker.Initialize(OutputData.ULD_Tray_TR_Down, InputData.ULD_Tray_Transfer_Up_Sensor, InputData.ULD_Tray_Transfer_Down_Sensor, En_Alarm_List.AL_0810_ULD_TRAY_TR_UP_SENSOR_CHECK, En_Alarm_List.AL_0811_ULD_TRAY_TR_DOWN_SENSOR_CHECK,
                OutputData.ULD_Tray_Transfer_Vaccum_On_Sol_Valve, OutputData.ULD_Tray_Transfer_Blow_On_Sol_Valve, InputData.ULD_Tray_Transfer_Vaccum_On_Check, En_Alarm_List.AL_0812_ULD_TRAY_TR_VACUUM_ON_CHECK);

            pauseDisableList.Add(TrayTransferSteps.S1205_MOVE_STAY_POSITION_CHECK);
            pauseDisableList.Add(TrayTransferSteps.S2205_MOVE_PICK_POSITION_CHECK);
            pauseDisableList.Add(TrayTransferSteps.S3205_MOVE_PLACE_POSITION_CHECK);

            MotorX.Check_Jog_Interlock = Jog_Interlock;
            MotorX.Check_Move_Interlock = Move_Interlock;
            MotorX.Check_Home_Interlock = Home_Interlock;
            _tactTime.Reset();
        }
        #endregion

        #region Function
        private bool Home_Interlock()
        {
            if (Get_Picker_Down_Sensor_Check())
            {
                Interlock_Manager.Add_Interlock_Msg("ULD Tray Tr", "Picker is Down, Can't Move.");
                return true;
            }

            return false;
        }

        private bool Move_Interlock()
        {
            if (Picker.IsDownSensor)
            {
                Interlock_Manager.Add_Interlock_Msg("ULD Tray Tr", "Picker is Down, Can't Move.");
                return true;
            }

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

            return false;
        }

        private bool Jog_Interlock(bool positive)
        {
            if (Picker.IsDownSensor)
            {
                Interlock_Manager.Add_Interlock_Msg("ULD Tray Tr", "Picker is Down, Can't Move.");
                return true;
            }

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

            return false;
        }

        public void Init_Seq()
        {
            Step = TrayTransferSteps.S0000_WAIT;
            _homeStep = TrayTransferHomeSteps.S0000_WAIT;
        }

        public void ExecuteAuto()
        {
            if (IsWorkEnd)
            {
                if(IsStayPosition == false)
                {
                    Step = TrayTransferSteps.S1000_MOVE_STAY_POSITION_START;
                }
                else
                {
                    if (Picker.IsVacuumSensor)
                    {
                        if (equipment.unloader.LiftOk.Step != LiftOutSteps.S1520_TRAY_ID_READ_WAIT && equipment.unloader.LiftNg.Step != LiftOutSteps.S1520_TRAY_ID_READ_WAIT)
                        {
                            if (equipment.unloader.LiftOk.Step == LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT)
                            {
                                Step = TrayTransferSteps.S3000_PLACE_TRAY_START;
                            }

                            if (equipment.unloader.LiftNg.Step == LiftOutSteps.S1400_TRAY_TRANSFER_PLACE_WAIT)
                            {
                                Step = TrayTransferSteps.S4000_PLACE_TRAY_START;
                            }
                        }
                    }
                    else
                    {
                        if (equipment.unloader.LiftIn.is_Tray_Place_Enable)
                        {
                            Step = TrayTransferSteps.S2000_PICK_TRAY_START;
                        }
                    }
                }
            }
        }

        public override void MonitoringStatus()
        {
            if (UnitMode == En_Equipment_Mode.Auto || UnitMode == En_Equipment_Mode.Manual)
            {
                if (IsWorkEnd)
                {
                    if (Get_Vacuum_On_Check() && !Get_Vacuum_Check())
                    {
                        Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0812_ULD_TRAY_TR_VACUUM_ON_CHECK);
                    }
                }
            }

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

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

            Picker.ExecuteProcess();

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

                MoveStay();
                PickTray();
                PlaceTrayOk();
                PlaceTrayNg();
            }
        }
        
        public void ExecuteHome()
        {
            switch(_homeStep)
            {
                case TrayTransferHomeSteps.S0000_WAIT:
                    {
                        _homeStep = TrayTransferHomeSteps.S1000_STATUS_CHECK;
                        break;
                    }
                case TrayTransferHomeSteps.S1000_STATUS_CHECK:
                    {
                        if (MotorX.ErrorStop)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0481_ULD_TRAY_TR_X_ERROR_STOP);
                        }
                        else if (MotorX.PowerOn == false)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0480_ULD_TRAY_TR_X_POWER_OFF);
                        }
                        else if (Picker.IsUp == false)
                        {
                            Interlock_Manager.Add_Interlock_Msg("ULD Tray TR Home can't run.", "Picker is Down.");
                        }
                        else
                        {
                            _homeStep = TrayTransferHomeSteps.S1100_LIFT_LIMIT_SENSOR_CHECK;
                        }
                        break;
                    }
                case TrayTransferHomeSteps.S1100_LIFT_LIMIT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsLiftLimitSensor1 || equipment.unloader.LiftIn.IsLiftLimitSensor2 || equipment.unloader.LiftOk.IsLiftLimitSensor1 || equipment.unloader.LiftOk.IsLiftLimitSensor2
                            || equipment.unloader.LiftNg.IsLiftLimitSensor1 || equipment.unloader.LiftNg.IsLiftLimitSensor2)
                        {
                            if (equipment.unloader.LiftIn.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0713_ULD_TRAY_EMPTY_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftIn.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0714_ULD_TRAY_EMPTY_LIFT_UP_1_2_SENSOR_CHECK);
                            }
                            
                            if (equipment.unloader.LiftOk.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0753_ULD_TRAY_OK_LIFT_UP_1_1_SENSOR_CHECK);
                            }

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

                            if (equipment.unloader.LiftNg.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0780_ULD_TRAY_NG_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftNg.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0781_ULD_TRAY_NG_LIFT_UP_1_2_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            _homeStep = TrayTransferHomeSteps.S2000_X_HOME_START;
                        }
                        break;
                    }
                case TrayTransferHomeSteps.S2000_X_HOME_START:
                    {
                        if (MotorX.Home())
                        {
                            homeCheckedTime.Restart();
                            _homeStep = TrayTransferHomeSteps.S2100_X_HOME_CHECK;
                        }
                        break;
                    }
                case TrayTransferHomeSteps.S2100_X_HOME_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (!MotorX.IsHomed)
                        {
                            if (MotorX.Homing == false && MotorX.ErrorStop)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0481_ULD_TRAY_TR_X_ERROR_STOP);
                                _homeStep = TrayTransferHomeSteps.S0000_WAIT;
                            }
                        }
                        else
                        {
                            _homeStep = TrayTransferHomeSteps.S3000_MOVE_STAY_POSITION;
                        }
                        break;
                    }
                case TrayTransferHomeSteps.S3000_MOVE_STAY_POSITION:
                    {
                        if (MoveLiftInPosition())
                        {
                            homeCheckedTime.Restart();
                            _homeStep = TrayTransferHomeSteps.S3100_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferHomeSteps.S3100_POSITION_CHECK:
                    {
                        if (homeCheckedTime.Seconds < 1) return;

                        if (MotorX.ErrorStop)
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0481_ULD_TRAY_TR_X_ERROR_STOP);
                            _homeStep = TrayTransferHomeSteps.S0000_WAIT;
                        }
                        else if (MotorX.MotionComplete)
                        {
                            if (IsStayPosition)
                            {
                                _homeStep = TrayTransferHomeSteps.S9999_END;
                            }
                            else
                            {
                                Interlock_Manager.Add_Interlock_Msg("ULD Tray TR Home can't run.", "Position is not empty.");
                                _homeStep = TrayTransferHomeSteps.S0000_WAIT;
                            }
                        }
                        break;
                    }
                case TrayTransferHomeSteps.S9999_END:
                    {
                        isHomeComplete = true;
                        _homeStep = TrayTransferHomeSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void MoveStay()
        {
            switch (Step)
            {
                case TrayTransferSteps.S1000_MOVE_STAY_POSITION_START:
                    {
                        _tactTime.Restart();
                        Step = TrayTransferSteps.S1100_PICKER_UP;
                        break;
                    }
                case TrayTransferSteps.S1100_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S1110_LIFT_LIMIT_SENSOR_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S1110_LIFT_LIMIT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsLiftLimitSensor1 || equipment.unloader.LiftIn.IsLiftLimitSensor2 || equipment.unloader.LiftOk.IsLiftLimitSensor1 || equipment.unloader.LiftOk.IsLiftLimitSensor2
                             || equipment.unloader.LiftNg.IsLiftLimitSensor1 || equipment.unloader.LiftNg.IsLiftLimitSensor2)
                        {
                            if (equipment.unloader.LiftIn.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0713_ULD_TRAY_EMPTY_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftIn.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0714_ULD_TRAY_EMPTY_LIFT_UP_1_2_SENSOR_CHECK);
                            }

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

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

                            if (equipment.unloader.LiftNg.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0780_ULD_TRAY_NG_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftNg.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0781_ULD_TRAY_NG_LIFT_UP_1_2_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = TrayTransferSteps.S1200_MOVE_STAY_POSITION;
                        }
                        break;
                    }
                case TrayTransferSteps.S1200_MOVE_STAY_POSITION:
                    {
                        if (MoveLiftInPosition())
                        {
                            Step = TrayTransferSteps.S1205_MOVE_STAY_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S1205_MOVE_STAY_POSITION_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            if (IsStayPosition)
                            {
                                Step = TrayTransferSteps.S1999_MOVE_STAY_POSITION_END;
                            }
                            else
                            {
                                Step = TrayTransferSteps.S1200_MOVE_STAY_POSITION;
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S1999_MOVE_STAY_POSITION_END:
                    {
                        _tactTime.Stop();
                        Step = TrayTransferSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void PickTray()
        {
            switch(Step)
            {
                case TrayTransferSteps.S2000_PICK_TRAY_START:
                    {
                        _tactTime.Restart();
                        Step = TrayTransferSteps.S2100_PICKER_UP;
                        break;
                    }
                case TrayTransferSteps.S2100_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S2110_LIFT_LIMIT_SENSOR_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2110_LIFT_LIMIT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsLiftLimitSensor1 || equipment.unloader.LiftIn.IsLiftLimitSensor2)
                        {
                            if (equipment.unloader.LiftIn.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0713_ULD_TRAY_EMPTY_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftIn.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0714_ULD_TRAY_EMPTY_LIFT_UP_1_2_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = TrayTransferSteps.S2120_HANDLER_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S2120_HANDLER_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 = TrayTransferSteps.S2130_LIFT_IN_SENSOR_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S2130_LIFT_IN_SENSOR_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsLiftInSensor1 && equipment.unloader.LiftIn.IsLiftInSensor2)
                        {
                            Step = TrayTransferSteps.S2200_MOVE_PICK_POSITION;
                        }
                        else
                        {
                            if (equipment.unloader.LiftIn.IsLiftInSensor1 == false)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0715_ULD_TRAY_EMPTY_LIFT_UP_2_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftIn.IsLiftInSensor2 == false)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0716_ULD_TRAY_EMPTY_LIFT_UP_2_2_SENSOR_CHECK);
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2200_MOVE_PICK_POSITION:
                    {
                        if (MoveLiftInPosition())
                        {
                            Step = TrayTransferSteps.S2205_MOVE_PICK_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S2205_MOVE_PICK_POSITION_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            if (IsStayPosition)
                            {
                                Step = TrayTransferSteps.S2300_PICKER_DOWN;
                            }
                            else
                            {
                                Step = TrayTransferSteps.S2200_MOVE_PICK_POSITION;
                            }
                        }

                        break;
                    }
                case TrayTransferSteps.S2300_PICKER_DOWN:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsDown)
                            {
                                Step = TrayTransferSteps.S2310_VACUUM_ON;
                            }
                            else
                            {
                                Picker.Down();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2310_VACUUM_ON:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsVacuumSensor)
                            {
                                Step = TrayTransferSteps.S2320_ALIGN_TOP_BACKWARD;
                            }
                            else
                            {
                                Picker.VacuumOn();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2320_ALIGN_TOP_BACKWARD:
                    {
                        if (equipment.unloader.LiftIn.AlignerTop.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftIn.AlignerTop.IsBackward)
                            {
                                Step = TrayTransferSteps.S2330_STACKER_BACKWARD;
                            }
                            else
                            {
                                equipment.unloader.LiftIn.AlignerTop.Backward();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2330_STACKER_BACKWARD:
                    {
                        if (equipment.unloader.LiftIn.Stacker.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftIn.Stacker.IsBackward)
                            {
                                Step = TrayTransferSteps.S2340_UNCLAMP;
                            }
                            else
                            {
                                equipment.unloader.LiftIn.Stacker.Backward();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2340_UNCLAMP:
                    {
                        if (equipment.unloader.LiftIn.Clamper.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftIn.Clamper.IsUnclamp)
                            {
                                Step = TrayTransferSteps.S2350_PICKER_UP;
                            }
                            else
                            {
                                equipment.unloader.LiftIn.Clamper.Unclamp();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2350_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S2360_VACUUM_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S2360_VACUUM_CHECK:
                    {
                        if (Picker.IsVacuumSensor)
                        {
                            Step = TrayTransferSteps.S2370_TRAY_COUNT_SET;
                        }
                        else
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0812_ULD_TRAY_TR_VACUUM_ON_CHECK);
                        }
                        break;
                    }
                case TrayTransferSteps.S2370_TRAY_COUNT_SET:
                    {
                        if (equipment.unloader.LiftIn.IsFirstTray)
                        {
                            equipment.unloader.LiftIn.IsFirstTray = false;
                        }

                        equipment.UnloaderInTrayCount = equipment.UnloaderInTrayCount - 1;

                        Step = TrayTransferSteps.S2999_PICK_TRAY_END;
                        break;
                    }
                case TrayTransferSteps.S2999_PICK_TRAY_END:
                    {
                        _tactTime.Stop();
                        Step = TrayTransferSteps.S0000_WAIT;
                        break;
                    }
            }
        }

        public void PlaceTrayOk()
        {
            switch (Step)
            {
                case TrayTransferSteps.S3000_PLACE_TRAY_START:
                    {
                        _tactTime.Start();
                        Step = TrayTransferSteps.S3100_PICKER_UP;
                        break;
                    }
                case TrayTransferSteps.S3100_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S3110_LIFT_LIMIT_SENSOR_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S3110_LIFT_LIMIT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsLiftLimitSensor1 || equipment.unloader.LiftIn.IsLiftLimitSensor2
                            || equipment.unloader.LiftOk.IsLiftLimitSensor1 || equipment.unloader.LiftOk.IsLiftLimitSensor2)
                        {
                            if (equipment.unloader.LiftIn.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0713_ULD_TRAY_EMPTY_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftIn.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0714_ULD_TRAY_EMPTY_LIFT_UP_1_2_SENSOR_CHECK);
                            }

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

                            if (equipment.unloader.LiftOk.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0754_ULD_TRAY_OK_LIFT_UP_1_2_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = TrayTransferSteps.S3120_HANDLER_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S3120_HANDLER_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 = TrayTransferSteps.S3200_MOVE_PLACE_POSITION;
                        }
                        break;
                    }
                case TrayTransferSteps.S3200_MOVE_PLACE_POSITION:
                    {
                        if (MoveLiftOkPosition())
                        {
                            Step = TrayTransferSteps.S3205_MOVE_PLACE_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S3205_MOVE_PLACE_POSITION_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            if (isLiftOkPosition)
                            {
                                Step = TrayTransferSteps.s3300_ALIGN_TOP_BACKWARD;
                            }
                            else
                            {
                                Step = TrayTransferSteps.S3200_MOVE_PLACE_POSITION;
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.s3300_ALIGN_TOP_BACKWARD:
                    {
                        if (equipment.unloader.LiftOk.AlignerTop.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftOk.AlignerTop.IsBackward)
                            {
                                Step = TrayTransferSteps.s3310_STACKER_BACKWARD;
                            }
                            else
                            {
                                equipment.unloader.LiftOk.AlignerTop.Backward();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.s3310_STACKER_BACKWARD:
                    {
                        if (equipment.unloader.LiftOk.Stacker.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftOk.Stacker.IsBackward)
                            {
                                Step = TrayTransferSteps.s3320_UNCLAMP;
                            }
                            else
                            {
                                equipment.unloader.LiftOk.Stacker.Backward();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.s3320_UNCLAMP:
                    {
                        if (equipment.unloader.LiftOk.Clamper.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftOk.Clamper.IsUnclamp)
                            {
                                Step = TrayTransferSteps.S3330_PICKER_DOWN;
                            }
                            else
                            {
                                equipment.unloader.LiftOk.Clamper.Unclamp();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S3330_PICKER_DOWN:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsDown)
                            {
                                Step = TrayTransferSteps.S3340_VACUUM_OFF;
                            }
                            else
                            {
                                Picker.Down();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S3340_VACUUM_OFF:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.VacuumSolOn == false)
                            {
                                Step = TrayTransferSteps.S3350_PICKER_UP;
                            }
                            else
                            {
                                Picker.VacuumOff();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S3350_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S3360_VACUUM_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S3360_VACUUM_CHECK:
                    {
                        if (Picker.IsVacuumSensor == false)
                        {
                            Step = TrayTransferSteps.S3370_TRAY_COUNT_SET;
                        }
                        else
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0812_ULD_TRAY_TR_VACUUM_ON_CHECK);
                        }
                        break;
                    }
                case TrayTransferSteps.S3370_TRAY_COUNT_SET:
                    {
                        equipment.UnloaderOkTrayCount = equipment.UnloaderOkTrayCount + 1;
                        Step = TrayTransferSteps.S3999_PLACE_TRAY_END;
                        break;
                    }
                case TrayTransferSteps.S3999_PLACE_TRAY_END:
                    {
                        _tactTime.Stop();
                        Step = TrayTransferSteps.S1000_MOVE_STAY_POSITION_START;
                        break;
                    }
            }
        }

        public void PlaceTrayNg()
        {
            switch (Step)
            {
                case TrayTransferSteps.S4000_PLACE_TRAY_START:
                    {
                        _tactTime.Start();
                        Step = TrayTransferSteps.S4100_PICKER_UP;
                        break;
                    }
                case TrayTransferSteps.S4100_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S4110_LIFT_LIMIT_SENSOR_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4110_LIFT_LIMIT_SENSOR_CHECK:
                    {
                        if (equipment.unloader.LiftIn.IsLiftLimitSensor1 || equipment.unloader.LiftIn.IsLiftLimitSensor2
                            || equipment.unloader.LiftNg.IsLiftLimitSensor1 || equipment.unloader.LiftNg.IsLiftLimitSensor2)
                        {
                            if (equipment.unloader.LiftIn.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0713_ULD_TRAY_EMPTY_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftIn.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0714_ULD_TRAY_EMPTY_LIFT_UP_1_2_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftNg.IsLiftLimitSensor1)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0780_ULD_TRAY_NG_LIFT_UP_1_1_SENSOR_CHECK);
                            }

                            if (equipment.unloader.LiftNg.IsLiftLimitSensor2)
                            {
                                Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0781_ULD_TRAY_NG_LIFT_UP_1_2_SENSOR_CHECK);
                            }
                        }
                        else
                        {
                            Step = TrayTransferSteps.S4120_HANDLER_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S4120_HANDLER_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 = TrayTransferSteps.S4200_MOVE_PLACE_POSITION;
                        }
                        break;
                    }
                case TrayTransferSteps.S4200_MOVE_PLACE_POSITION:
                    {
                        if (MoveLiftNgPosition())
                        {
                            Step = TrayTransferSteps.S4205_MOVE_PLACE_POSITION_CHECK;
                        }
                        break;
                    }
                case TrayTransferSteps.S4205_MOVE_PLACE_POSITION_CHECK:
                    {
                        if (MotorX.MotionComplete)
                        {
                            if (isLiftNgPosition)
                            {
                                Step = TrayTransferSteps.S4300_ALIGN_TOP_BACKWARD;
                            }
                            else
                            {
                                Step = TrayTransferSteps.S4200_MOVE_PLACE_POSITION;
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4300_ALIGN_TOP_BACKWARD:
                    {
                        if (equipment.unloader.LiftNg.AlignerTop.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftNg.AlignerTop.IsBackward)
                            {
                                Step = TrayTransferSteps.S4310_STACKER_BACKWARD;
                            }
                            else
                            {
                                equipment.unloader.LiftNg.AlignerTop.Backward();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4310_STACKER_BACKWARD:
                    {
                        if (equipment.unloader.LiftNg.Stacker.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftNg.Stacker.IsBackward)
                            {
                                Step = TrayTransferSteps.S4320_UNCLAMP;
                            }
                            else
                            {
                                equipment.unloader.LiftNg.Stacker.Backward();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4320_UNCLAMP:
                    {
                        if (equipment.unloader.LiftNg.Clamper.IsWorkEnd)
                        {
                            if (equipment.unloader.LiftNg.Clamper.IsUnclamp)
                            {
                                Step = TrayTransferSteps.S4330_PICKER_DOWN;
                            }
                            else
                            {
                                equipment.unloader.LiftNg.Clamper.Unclamp();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4330_PICKER_DOWN:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsDown)
                            {
                                Step = TrayTransferSteps.S4340_VACUUM_OFF;
                            }
                            else
                            {
                                Picker.Down();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4340_VACUUM_OFF:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.VacuumSolOn == false)
                            {
                                Step = TrayTransferSteps.S4350_PICKER_UP;
                            }
                            else
                            {
                                Picker.VacuumOff();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4350_PICKER_UP:
                    {
                        if (Picker.IsWorkEnd)
                        {
                            if (Picker.IsUp)
                            {
                                Step = TrayTransferSteps.S4360_VACUUM_CHECK;
                            }
                            else
                            {
                                Picker.Up();
                            }
                        }
                        break;
                    }
                case TrayTransferSteps.S4360_VACUUM_CHECK:
                    {
                        if (Picker.IsVacuumSensor == false)
                        {
                            Step = TrayTransferSteps.S4370_TRAY_COUNT_SET;
                        }
                        else
                        {
                            Alarm_Manager.Instance.Occurred(En_Alarm_List.AL_0812_ULD_TRAY_TR_VACUUM_ON_CHECK);
                        }
                        break;
                    }
                case TrayTransferSteps.S4370_TRAY_COUNT_SET:
                    {
                        equipment.UnloaderNgTrayCount = equipment.UnloaderNgTrayCount + 1;
                        Step = TrayTransferSteps.S4999_PLACE_TRAY_END;
                        break;
                    }
                case TrayTransferSteps.S4999_PLACE_TRAY_END:
                    {
                        _tactTime.Stop();
                        Step = TrayTransferSteps.S1000_MOVE_STAY_POSITION_START;
                        break;
                    }
            }
        }

        public double Get_Current_Position_X_1()
        {
            
            double position;

            position = double.Parse(MotorX.Position.ToString("F3"));

            return position;
        }

        public bool Get_Vacuum_On_Check()
        {
            return equipment.sm.Get_Bit(Output_Memory_Address.ULD_Tray_Transfer_Vaccum_On_Sol_Valve);
        }

        public bool Get_Blow_On_Check()
        {
            return equipment.sm.Get_Bit(Output_Memory_Address.ULD_Tray_Transfer_Blow_On_Sol_Valve);
        }

        public bool Get_Vacuum_Check()
        {
            return equipment.sm.Get_Bit(Input_Memory_Address.ULD_Tray_Transfer_Vaccum_On_Check);
        }

        public bool Get_Picker_Down_On_Check()
        {
            return equipment.sm.Get_Bit(Output_Memory_Address.ULD_Tray_TR_Down);
        }

        public bool Get_Picker_Down_Sensor_Check()
        {
            return equipment.sm.Get_Bit(Input_Memory_Address.ULD_Tray_Transfer_Down_Sensor);
        }

        public bool Get_Picker_Up_Sensor_Check()
        {
            return equipment.sm.Get_Bit(Input_Memory_Address.ULD_Tray_Transfer_Up_Sensor);
        }

        public bool MoveLiftOkPosition()
        {

            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_X_OK_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_X_OK_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorX.Move_Absolute_Pos(position, velocity);
        }

        public bool MoveLiftNgPosition()
        {

            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_X_NG_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_X_NG_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorX.Move_Absolute_Pos(position, velocity);
        }

        public bool MoveLiftInPosition()
        {
            object value;
            double position;
            double velocity;
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_X_Empty_Position, out value);
            position = double.Parse($"{value}");
            equipment.sm.Get_Value(Position_Parameter_Address.ULD_Tray_X_Empty_Velocity, out value);
            velocity = double.Parse($"{value}");

            return MotorX.Move_Absolute_Pos(position, velocity);
        }

        public bool Set_Vacuum_On(bool onoff)
        {
            return equipment.Board_Control.IO_manager.Set_Output(OutputData.ULD_Tray_Transfer_Vaccum_On_Sol_Valve, onoff);
        }

        public bool Set_Blow_On(bool onoff)
        {
            return equipment.Board_Control.IO_manager.Set_Output(OutputData.ULD_Tray_Transfer_Blow_On_Sol_Valve, onoff);
        }

        public bool Set_Picker_Down(bool onoff)
        {
            return equipment.Board_Control.IO_manager.Set_Output(OutputData.ULD_Tray_TR_Down, onoff);
        }
        #endregion
    }
}