namespace SHARP_CLAS_UI
{
    public class TrayShuttle
    {
        #region Enum
        private enum ProcessSteps
        {
            Wait,

            //Shuttle Forward
            BeforeBackwardSolOff,
            BeforeBackwardSolOffCheck,
            ForwardSolOn,
            ForwardSolOnCheck,
            ForwardSensorCheck,

            //Shuttle Backward
            BeforeForwardSolOff,
            BeforeForwardSolOffCheck,
            BackwardSolOn,
            BackwardSolOnCheck,
            BackwardSensorCheck,
        }
        #endregion
        
        #region Property
        public bool ForwardOnSol
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_forwardOnSol);
            }

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

        public bool BackwardOnSol
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_backwardOnSol);
            }

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

        public bool IsForwardSensor
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_forwardSensor);
            }
        }

        public bool IsBackwardSensor
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_backwardSensor);
            }
        }

        public bool IsForward
        {
            get
            {
                if(ForwardOnSol == true && BackwardOnSol == false && IsForwardSensor)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        
        public bool IsBackward
        {
            get
            {
                if (ForwardOnSol == false && BackwardOnSol == true && IsBackwardSensor)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

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

        #region Field
        private Equipment _equip;
        private OutputData _forwardOnSol;
        private OutputData _backwardOnSol;
        private InputData _forwardSensor;
        private InputData _backwardSensor;

        private En_Alarm_List _forwardSensorAlarm;
        private En_Alarm_List _backwardSensorAlarm;

        private ProcessSteps _step;
        private SequenceTimer _sequenceTimer;

        private readonly int _retryLimitCount = 3;
        private readonly int _sensorTimeout = 60;

        private int _retryCount;
        #endregion

        #region Construct
        public TrayShuttle(Equipment equip)
        {
            _equip = equip;
            _sequenceTimer = new SequenceTimer();

            _step = ProcessSteps.Wait;
        }
        #endregion

        #region Function
        public void Initialize(OutputData forwardOnSol, OutputData backwardOnSol, InputData forwardSensor, InputData backwardSensor, En_Alarm_List forwardSensorAlarm, En_Alarm_List backwardSensorAlarm)
        {
            _forwardOnSol = forwardOnSol;
            _backwardOnSol = backwardOnSol;
            _forwardSensor = forwardSensor;
            _backwardSensor = backwardSensor;
            _forwardSensorAlarm = forwardSensorAlarm;
            _backwardSensorAlarm = backwardSensorAlarm;
        }

        public void ExecuteProcess()
        {
            switch (_step)
            {
                case ProcessSteps.Wait:
                    {
                        break;
                    }
                case ProcessSteps.BeforeBackwardSolOff:
                    {
                        BackwardOnSol = false;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.BeforeBackwardSolOffCheck;
                        break;
                    }
                case ProcessSteps.BeforeBackwardSolOffCheck:
                    {
                        if(BackwardOnSol == false)
                        {
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.ForwardSolOn;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.BeforeBackwardSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_backwardOnSol} on fail.", $"{_backwardOnSol} on is fail (retry 3).");
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.ForwardSolOn:
                    {
                        ForwardOnSol = true;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.ForwardSolOnCheck;
                        break;
                    }
                case ProcessSteps.ForwardSolOnCheck:
                    {
                        if (ForwardOnSol)
                        {
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.ForwardSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.ForwardSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_forwardOnSol} on fail.", $"{_forwardOnSol} on is fail (retry 3).");
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.ForwardSensorCheck:
                    {
                        if(IsForwardSensor)
                        {
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _sensorTimeout)
                            {
                                Alarm_Manager.Instance.Occurred(_forwardSensorAlarm);
                                _step = ProcessSteps.Wait;
                            }
                        }
                        break;
                    }
                case ProcessSteps.BeforeForwardSolOff:
                    {
                        ForwardOnSol = false;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.BeforeForwardSolOffCheck;
                        break;
                    }
                case ProcessSteps.BeforeForwardSolOffCheck:
                    {
                        if (ForwardOnSol == false)
                        {
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.BackwardSolOn;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.BeforeForwardSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_forwardOnSol} on fail.", $"{_forwardOnSol} on is fail (retry 3).");
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.BackwardSolOn:
                    {
                        BackwardOnSol = true;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.BackwardSolOnCheck;
                        break;
                    }
                case ProcessSteps.BackwardSolOnCheck:
                    {
                        if (BackwardOnSol)
                        {
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.BackwardSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.BackwardSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_backwardOnSol} on fail.", $"{_backwardOnSol} on is fail (retry 3).");
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.BackwardSensorCheck:
                    {
                        if (IsBackwardSensor)
                        {
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _sensorTimeout)
                            {
                                Alarm_Manager.Instance.Occurred(_backwardSensorAlarm);
                                _step = ProcessSteps.Wait;
                            }
                        }
                        break;
                    }
            }

        }

        public bool Forward()
        {
            if(IsWorkEnd)
            {
                if(ForwardOnSol && BackwardOnSol == false && IsForwardSensor)
                {
                    return true;
                }
                else
                {
                    _step = ProcessSteps.BeforeBackwardSolOff;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        public bool Backward()
        {
            if (IsWorkEnd)
            {
                if (BackwardOnSol && ForwardOnSol == false && IsBackwardSensor)
                {
                    return true;
                }
                else
                {
                    _step = ProcessSteps.BeforeForwardSolOff;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion
    }
}