namespace SHARP_CLAS_UI
{
    public class Picker : VacuumStageCh1
    {
        #region Enum
        private enum ProcessSteps
        {
            Wait,

            PickerDownSolOn,
            PickerDownSolOnCheck,
            PickerDownSensorCheck,

            PickerDownSolOff,
            PickerDownSolOffCheck,
            PickerUpSensorCheck,
        }
        #endregion
        
        #region Property
        public bool DownSol
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_pickerDownSol);
            }

            set
            {
                _equip.Board_Control.IO_manager.Set_Output(_pickerDownSol, value);
            }
        }

        public bool IsUpSensor
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_isUpSensor);
            }
        }

        public bool IsDownSensor
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_isDownSensor);
            }
        }

        public bool IsDown
        {
            get
            {
                return DownSol && IsDownSensor;
            }
        }

        public bool IsUp
        {
            get
            {
                return DownSol == false && IsUpSensor;
            }
        }

        public new bool IsWorkEnd
        {
            get
            {
                if (_step == ProcessSteps.Wait && base.IsWorkEnd)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        #endregion

        #region Field
        Equipment _equip;

        private OutputData _pickerDownSol;
        private InputData _isUpSensor;
        private InputData _isDownSensor;

        private En_Alarm_List _pickerUpSensorAlarm;
        private En_Alarm_List _pickerDownSensorAlarm;

        private ProcessSteps _step;
        private SequenceTimer _sequenceTimer;

        private readonly int _retryLimitCount = 3;
        private int _retryCount;
        #endregion

        #region Construct
        public Picker(Equipment equip) : base (equip)
        {
            _equip = equip;
            _retryCount = 0;

            _sequenceTimer = new SequenceTimer();
            _step = ProcessSteps.Wait;
        }
        #endregion

        #region Function
        public void Initialize(OutputData pickerDownSol, InputData isPickerUp, InputData isPickerDown, En_Alarm_List pickerUpSensorAlarm, En_Alarm_List pickerDownSensorAlarm
           , OutputData vacuumSolOn, OutputData blowSolOn, InputData isVacuumOn, En_Alarm_List vacuumSensorAlarm)
        {
            base.Initialize(vacuumSolOn, blowSolOn, isVacuumOn, vacuumSensorAlarm);

            _pickerDownSol = pickerDownSol;
            _isUpSensor = isPickerUp;
            _isDownSensor = isPickerDown;
            _pickerUpSensorAlarm = pickerUpSensorAlarm;
            _pickerDownSensorAlarm = pickerDownSensorAlarm;
        }

        public new void ExecuteProcess()
        {
            base.ExecuteProcess();

            switch (_step)
            {
                case ProcessSteps.Wait:
                    {
                        break;
                    }
                case ProcessSteps.PickerDownSolOn:
                    {
                        DownSol = true;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.PickerDownSolOnCheck;
                        break;
                    }
                case ProcessSteps.PickerDownSolOnCheck:
                    {
                        if (DownSol == true)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.PickerDownSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 1)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.PickerDownSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_pickerDownSol} on fail.", $"{_pickerDownSol} on is fail (retry 3).");
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.PickerDownSensorCheck:
                    {
                        if (IsDownSensor == true)
                        {
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _equip.Setting.Cylinder_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(_pickerDownSensorAlarm);
                                _step = ProcessSteps.Wait;
                            }
                        }
                        break;
                    }
                case ProcessSteps.PickerDownSolOff:
                    {
                        DownSol = false;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.PickerDownSolOffCheck;
                        break;
                    }
                case ProcessSteps.PickerDownSolOffCheck:
                    {
                        if (DownSol == false)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.PickerUpSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 1)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.PickerDownSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_pickerDownSol} off fail.", $"{_pickerDownSol} off is fail (retry 3).");
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.PickerUpSensorCheck:
                    {
                        if (IsUpSensor == true)
                        {
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _equip.Setting.Cylinder_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(_pickerUpSensorAlarm);
                                _step = ProcessSteps.Wait;
                            }
                        }
                        break;
                    }
            }
        }
        
        public bool Up()
        {
            if (IsWorkEnd)
            {
                if (DownSol == false && IsUpSensor)
                {
                    if (IsDownSensor)
                    {
                        Alarm_Manager.Instance.Occurred(_pickerDownSensorAlarm);
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                else
                {
                    _step = ProcessSteps.PickerDownSolOff;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        public bool Down()
        {
            if (IsWorkEnd)
            {
                if (DownSol && IsDownSensor)
                {
                    if (IsUpSensor)
                    {
                        Alarm_Manager.Instance.Occurred(_pickerUpSensorAlarm);
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                else
                {
                    _step = ProcessSteps.PickerDownSolOn;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion
    }
}