namespace SHARP_CLAS_UI
{
    public class PickerUnit : StageUnit
    {
        #region Enum
        private enum PickerUnitWork
        {
            Wait,

            PickerDownSolOn,
            PickerDownSolOnCheck,
            PickerDownSensorCheck,

            PickerDownSolOff,
            PickerDownSolOffCheck,
            PickerUpSensorCheck,
        }
        #endregion

        #region Property
        public bool PickerDownSol
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_pickerDownSol);
            }

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

        public bool IsPickerUp
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_isPickerUp);
            }
        }

        public bool IsPickerDown
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_isPickerDown);
            }
        }

        public bool IsUnitWorkEnd
        {
            get
            {
                if (_pickerUnitWorking == PickerUnitWork.Wait)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        #endregion

        #region Field
        Equipment _equip;

        private OutputData _pickerDownSol;
        private InputData _isPickerUp;
        private InputData _isPickerDown;

        private En_Alarm_List _pickerUpSensorAlarm;
        private En_Alarm_List _pickerDownSensorAlarm;

        private PickerUnitWork _pickerUnitWorking;
        private Time_Checker _sequenceTimer;

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

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

            _sequenceTimer = new Time_Checker();
            _pickerUnitWorking = PickerUnitWork.Wait;
        }
        #endregion

        #region Function
        public void PickerUnitInitialize(OutputData pickerDownSol, InputData isPickerUp, InputData isPickerDown)
        {
            _pickerDownSol = pickerDownSol;
            _isPickerUp = isPickerUp;
            _isPickerDown = isPickerDown;
        }

        public void PickerUnitAlarmInitialize(En_Alarm_List pickerUpSensorAlarm, En_Alarm_List pickerDownSensorAlarm)
        {
            _pickerUpSensorAlarm = pickerUpSensorAlarm;
            _pickerDownSensorAlarm = pickerDownSensorAlarm;
        }

        public void PickerUnitLogicWorking()
        {
            switch (_pickerUnitWorking)
            {
                case PickerUnitWork.Wait:
                    {
                        break;
                    }
                case PickerUnitWork.PickerDownSolOn:
                    {
                        PickerDownSol = true;
                        _sequenceTimer.Start();
                        _pickerUnitWorking = PickerUnitWork.PickerDownSolOnCheck;
                        break;
                    }
                case PickerUnitWork.PickerDownSolOnCheck:
                    {
                        if (PickerDownSol == true)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Start();
                            _pickerUnitWorking = PickerUnitWork.PickerDownSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 1)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _pickerUnitWorking = PickerUnitWork.PickerDownSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_pickerDownSol} on fail.", $"{_pickerDownSol} on is fail (retry 3).");
                                    _pickerUnitWorking = PickerUnitWork.Wait;
                                }
                            }
                        }
                        break;
                    }
                case PickerUnitWork.PickerDownSensorCheck:
                    {
                        if (IsPickerDown == true)
                        {
                            _sequenceTimer.Stop();
                            _pickerUnitWorking = PickerUnitWork.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _equip.Setting.Cylinder_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(_pickerDownSensorAlarm);
                                _pickerUnitWorking = PickerUnitWork.Wait;
                            }
                        }
                        break;
                    }
                case PickerUnitWork.PickerDownSolOff:
                    {
                        PickerDownSol = false;
                        _sequenceTimer.Start();
                        _pickerUnitWorking = PickerUnitWork.PickerDownSolOffCheck;
                        break;
                    }
                case PickerUnitWork.PickerDownSolOffCheck:
                    {
                        if (PickerDownSol == false)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Start();
                            _pickerUnitWorking = PickerUnitWork.PickerUpSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 1)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _pickerUnitWorking = PickerUnitWork.PickerDownSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;
                                    Interlock_Manager.Add_Interlock_Msg($"{_pickerDownSol} off fail.", $"{_pickerDownSol} off is fail (retry 3).");
                                    _pickerUnitWorking = PickerUnitWork.Wait;
                                }
                            }
                        }
                        break;
                    }
                case PickerUnitWork.PickerUpSensorCheck:
                    {
                        if (IsPickerUp == true)
                        {
                            _sequenceTimer.Stop();
                            _pickerUnitWorking = PickerUnitWork.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _equip.Setting.Cylinder_Timeout)
                            {
                                Alarm_Manager.Instance.Occurred(_pickerUpSensorAlarm);
                                _pickerUnitWorking = PickerUnitWork.Wait;
                            }
                        }
                        break;
                    }
            }
        }

        /// <summary>
        /// Picker Up 상태 확인, Up 안되어 있을 시 up sequence 동작.
        /// </summary>
        /// <returns></returns>
        public bool Up()
        {
            if (IsUnitWorkEnd)
            {
                if (IsPickerUp && PickerDownSol == false)
                {
                    if(IsPickerDown)
                    {
                        Alarm_Manager.Instance.Occurred(_pickerDownSensorAlarm);
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                else
                {
                    _pickerUnitWorking = PickerUnitWork.PickerDownSolOff;
                    return false;
                }
            }
            else
            {
                return false;
            }
        }

        public bool Down()
        {
            if (IsUnitWorkEnd)
            {
                if(IsPickerDown && PickerDownSol)
                {
                    if (IsPickerUp)
                    {
                        Alarm_Manager.Instance.Occurred(_pickerUpSensorAlarm);
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                else
                {
                    _pickerUnitWorking = PickerUnitWork.PickerDownSolOn;
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion
    }
}