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

            BeforeBlowSolOn,
            BeforeBlowSolOnCheck,
            BeforeBlowSolOff,
            BeforeBlowSolOffCheck,
            VacuumSolOn,
            VacuumSolOnCheck,
            IsVacuumSensorCheck,

            VacuumSolOff,
            VacuumSolOffCheck,
            AfterBlowSolOn,
            AfterBlowSolOnCheck,
            AfterBlowSolOff,
            AfterBlowSolOffCheck,
            IsVacuumOffCheck,
        }
        #endregion

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

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

        public bool VacuumSol2On
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_vacuumSol2On);
            }

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

        public bool BlowSol1On
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_blowSol1On);
            }

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

        public bool BlowSol2On
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Output(_blowSol2On);
            }

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

        public bool IsVacuum1Sensor
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_isVacuum1On);
            }
        }
        
        public bool IsVacuum2Sensor
        {
            get
            {
                return _equip.Board_Control.IO_manager.Get_Input(_isVacuum2On);
            }
        }

        public bool IsVacuumSolOn
        {
            get
            {
                return VacuumSol1On && VacuumSol2On;
            }
        }

        public bool IsBlowSolOn
        {
            get
            {
                return BlowSol1On && BlowSol2On;
            }
        }
        public bool IsExist
        {
            get
            {
                return VacuumSol1On && VacuumSol2On && IsVacuum1Sensor && IsVacuum2Sensor;
            }
        }

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

        #region Field
        Equipment _equip;
        
        private OutputData _vacuumSol1On;
        private OutputData _vacuumSol2On;
        private OutputData _blowSol1On;
        private OutputData _blowSol2On;
        private InputData _isVacuum1On;
        private InputData _isVacuum2On;

        private En_Alarm_List _vacuumSensor1Alarm;
        private En_Alarm_List _vacuumSensor2Alarm;

        private ProcessSteps _step;
        private SequenceTimer _sequenceTimer;

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

        #region Construct
        public VacuumStageCh2(Equipment equip)
        {
            _equip = equip;
            _retryCount = 0;

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

        #region Function
        public void Initialize(OutputData vacuumSol1On, OutputData vacuumSol2On, OutputData blowSol1On, OutputData blowSol2On, InputData isVacuum1On, InputData isVacuum2On,
            En_Alarm_List vacuumSensor1Alarm, En_Alarm_List vacuumSensor2Alarm)
        {
            _vacuumSol1On = vacuumSol1On;
            _vacuumSol2On = vacuumSol2On;
            _blowSol1On = blowSol1On;
            _blowSol2On = blowSol2On;
            _isVacuum1On = isVacuum1On;
            _isVacuum2On = isVacuum2On;

            _vacuumSensor1Alarm = vacuumSensor1Alarm;
            _vacuumSensor2Alarm = vacuumSensor2Alarm;
        }

        public void ExecuteProcess()
        {
            switch (_step)
            {
                case ProcessSteps.Wait:
                    {
                        break;
                    }
                case ProcessSteps.BeforeBlowSolOn:
                    {
                        BlowSol1On = true;
                        BlowSol2On = true;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.BeforeBlowSolOnCheck;
                        break;
                    }
                case ProcessSteps.BeforeBlowSolOnCheck:
                    {
                        if (BlowSol1On == true && BlowSol2On == true)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.BeforeBlowSolOff;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.BeforeBlowSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;

                                    if (BlowSol1On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol1On} on fail.", $"{_blowSol1On} on is fail (retry 3).");
                                    }

                                    if (BlowSol2On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol2On} on fail.", $"{_blowSol2On} on is fail (retry 3).");
                                    }

                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.BeforeBlowSolOff:
                    {
                        BlowSol1On = false;
                        BlowSol2On = false;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.BeforeBlowSolOffCheck;
                        break;
                    }
                case ProcessSteps.BeforeBlowSolOffCheck:
                    {
                        if (BlowSol1On == false && BlowSol2On == false)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.VacuumSolOn;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.BeforeBlowSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;

                                    if (BlowSol1On == true)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol1On} off fail.", $"{_blowSol1On} off is fail (retry 3).");
                                    }

                                    if (BlowSol2On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol2On} off fail.", $"{_blowSol2On} off is fail (retry 3).");
                                    }

                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.VacuumSolOn:
                    {
                        VacuumSol1On = true;
                        VacuumSol2On = true;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.VacuumSolOnCheck;
                        break;
                    }
                case ProcessSteps.VacuumSolOnCheck:
                    {
                        if (VacuumSol1On == true && VacuumSol2On == true)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.IsVacuumSensorCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.VacuumSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;

                                    if(VacuumSol1On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_vacuumSol1On} on fail.", $"{_vacuumSol1On} on is fail (retry 3).");
                                    }

                                    if (VacuumSol1On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_vacuumSol2On} on fail.", $"{_vacuumSol2On} on is fail (retry 3).");
                                    }

                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.IsVacuumSensorCheck:
                    {
                        if (IsVacuum1Sensor == true && IsVacuum2Sensor == true)
                        {
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _equip.Setting.Vacuum_Timeout)
                            {
                                if(IsVacuum1Sensor == false)
                                {
                                    Alarm_Manager.Instance.Occurred(_vacuumSensor1Alarm);
                                }

                                if (IsVacuum2Sensor == false)
                                {
                                    Alarm_Manager.Instance.Occurred(_vacuumSensor2Alarm);
                                }

                                _step = ProcessSteps.Wait;
                            }
                        }
                        break;
                    }
                case ProcessSteps.VacuumSolOff:
                    {
                        VacuumSol1On = false;
                        VacuumSol2On = false;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.VacuumSolOffCheck;
                        break;
                    }
                case ProcessSteps.VacuumSolOffCheck:
                    {
                        if (VacuumSol1On == false && VacuumSol2On == false)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Restart();
                            _step = ProcessSteps.AfterBlowSolOn;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.VacuumSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;

                                    if (VacuumSol1On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_vacuumSol1On} off fail.", $"{_vacuumSol1On} off is fail (retry 3).");
                                    }

                                    if (VacuumSol1On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_vacuumSol2On} off fail.", $"{_vacuumSol2On} off is fail (retry 3).");
                                    }

                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.AfterBlowSolOn:
                    {
                        BlowSol1On = true;
                        BlowSol2On = true;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.AfterBlowSolOnCheck;
                        break;
                    }
                case ProcessSteps.AfterBlowSolOnCheck:
                    {
                        if (BlowSol1On == true && BlowSol2On == true)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.AfterBlowSolOff;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.AfterBlowSolOn;
                                }
                                else
                                {
                                    _retryCount = 0;

                                    if (BlowSol1On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol1On} on fail.", $"{_blowSol1On} on is fail (retry 3).");
                                    }

                                    if (BlowSol2On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol2On} on fail.", $"{_blowSol2On} on is fail (retry 3).");
                                    }

                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.AfterBlowSolOff:
                    {
                        BlowSol1On = false;
                        BlowSol2On = false;
                        _sequenceTimer.Restart();
                        _step = ProcessSteps.AfterBlowSolOffCheck;
                        break;
                    }
                case ProcessSteps.AfterBlowSolOffCheck:
                    {
                        if (BlowSol1On == false && BlowSol2On == false)
                        {
                            _retryCount = 0;
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.IsVacuumOffCheck;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > 3)
                            {
                                if (_retryCount < _retryLimitCount)
                                {
                                    _retryCount++;
                                    _step = ProcessSteps.AfterBlowSolOff;
                                }
                                else
                                {
                                    _retryCount = 0;

                                    if (BlowSol1On == true)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol1On} off fail.", $"{_blowSol1On} off is fail (retry 3).");
                                    }

                                    if (BlowSol2On == false)
                                    {
                                        Interlock_Manager.Add_Interlock_Msg($"{_blowSol2On} off fail.", $"{_blowSol2On} off is fail (retry 3).");
                                    }
                                    
                                    _step = ProcessSteps.Wait;
                                }
                            }
                        }
                        break;
                    }
                case ProcessSteps.IsVacuumOffCheck:
                    {
                        if (IsVacuum1Sensor == false && IsVacuum2Sensor == false)
                        {
                            _sequenceTimer.Reset();
                            _step = ProcessSteps.Wait;
                        }
                        else
                        {
                            if (_sequenceTimer.Seconds > _equip.Setting.Vacuum_Timeout)
                            {
                                if (IsVacuum1Sensor == true)
                                {
                                    Alarm_Manager.Instance.Occurred(_vacuumSensor1Alarm);
                                }

                                if (IsVacuum2Sensor == true)
                                {
                                    Alarm_Manager.Instance.Occurred(_vacuumSensor2Alarm);
                                }

                                _step = ProcessSteps.Wait;
                            }
                        }
                        break;
                    }
            }
        }

        public bool VacuumOn()
        {
            if (IsWorkEnd)
            {
                if (VacuumSol1On && VacuumSol2On && IsVacuum1Sensor && IsVacuum2Sensor)
                {
                    return true;
                }
                else
                {
                    _step = ProcessSteps.BeforeBlowSolOn;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        public bool VacuumOff()
        {
            if (IsWorkEnd)
            {
                if (VacuumSol1On == false && VacuumSol2On == false && IsVacuum1Sensor == false && IsVacuum2Sensor == false)
                {
                    return true;
                }
                else
                {
                    _step = ProcessSteps.VacuumSolOff;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion
    }
}