using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
using FurnaceRT.Devices;
using FurnaceRT.Equipments.PMs.Devices;
using FurnaceRT.Extraction;
using MECF.Framework.Common.CommonData.SorterDefines;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK;
using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace FurnaceRT.Equipments.PMs
{
    /// <summary>
    /// 分布类 定义N2Purge的执行逻辑
    /// </summary>
    public partial class PMModule
    {
        private R_TRIG _trigN2UpRD = new R_TRIG();
        private R_TRIG _trigN2DownRD = new R_TRIG();
        private R_TRIG _trigN2AirUpRD = new R_TRIG();
        private R_TRIG _trigN2AirDownRD = new R_TRIG();
        private R_TRIG _trigN2AirDownTwoRD = new R_TRIG();
        private R_TRIG _trigSelectN2PurgeModeD = new R_TRIG();

        private Dictionary<string, Tuple<R_TRIG, List<Tuple<IDevice, string>>>> _n2PurgeSequenceAction;
        private Dictionary<string, Func<bool>> _n2PurgeSequenceStatus;
        private Dictionary<string, R_TRIG> _rTrigDict;
        private N2PurgeModeEnum _N2PurgeMode = N2PurgeModeEnum.Auto;
        private double _n2PurgeData = 20;
        private double _n2ToAirData = 185000;
        private N2PurgeModeEnum _currentPhase;
        private double _manualPhase2StabilityTime = 0;
        private double _manualPhase4StabilityTime = 0;

        private bool _enableAbortN2purge = true;

        private int _phase1CycleCount = 0;
        private int _phase1CycleCountSC = 0;
        private bool _canSwitchToPhase2 = true;

        private Dictionary<string, Stopwatch> _allTimeDict = new Dictionary<string, Stopwatch>();
        private void InitN2PurgeData()
        {
            DATA.Subscribe($"{Module}.N2PurgeLimitData", () => GetN2PurgeLimitData());
            DATA.Subscribe($"{Module}.O2DensityData", () => ConcentrationO2.Value.ToString("f3"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CheckO2Location", () => GetCheckO2Location(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.O2SetCheckSetPoint", () => GetO2SetCheckSetPoint(), SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.N2PurgeMode", () => SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : "");




            var selectN2PurgeMode = SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : "";
            if (!string.IsNullOrEmpty(selectN2PurgeMode))
            {
                if (selectN2PurgeMode != _N2PurgeMode.ToString())
                {
                    SetN2PurgeModeAction(selectN2PurgeMode);
                }
            }

            var currentPhase = SC.ContainsItem("PM1.SelectN2PurgeModePhase") ? SC.GetStringValue("PM1.SelectN2PurgeModePhase") : "";
            if (!string.IsNullOrEmpty(currentPhase))
            {
                var enumCurrentPhase = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), currentPhase);
                _currentPhase = enumCurrentPhase;
            }
        }

        private void InitN2PurgeConfigData()
        {
            _n2PurgeData = SC.ContainsItem($"System.N2PurgeData") ? SC.GetValue<double>("System.N2PurgeData") : 20;
            _n2ToAirData = SC.ContainsItem($"System.N2PurgeData") ? SC.GetValue<double>("System.N2ToAirData") : 185000;

            _enableAbortN2purge = SC.ContainsItem($"PM1.N2Purge.EnableAbortN2purge") ? SC.GetValue<bool>("PM1.N2Purge.EnableAbortN2purge") : false;

            _manualPhase2StabilityTime = SC.ContainsItem($"PM1.N2Purge.Manual_phase2.StabilityTime") ? SC.GetValue<double>("PM1.N2Purge.Manual_phase2.StabilityTime") : 0;
            _manualPhase4StabilityTime = SC.ContainsItem($"PM1.N2Purge.Manual_phase4.StabilityTime") ? SC.GetValue<double>("PM1.N2Purge.Manual_phase4.StabilityTime") : 0;

            _phase1CycleCountSC = SC.ContainsItem($"PM1.N2Purge.Manual_phase1.CycleCount") ? SC.GetValue<int>("PM1.N2Purge.Manual_phase1.CycleCount") : 0;


            _n2PurgeSequenceAction = ExtractionMethods.GetN2PurgeSequenceAction();
            _n2PurgeSequenceStatus = new Dictionary<string, Func<bool>>()
            {
                {"N2PurgeAIRTo20PPM",()=> GetN2PurgeAIRTo20PPMStatus()},
                {"N2PurgeUnder20PPM",()=> GetN2PurgeUnder20PPMStatus()},
                {"AIR",()=> GetN2PurgeAIRStatus()},
                {"DoorOpen",()=> GetN2PurgeDoorOpenStatus()},
                {"Foup1",()=> GetN2PurgeFoup1Status()},
                {"Foup2",()=> GetN2PurgeFoup2Status()},

                {N2PurgeModeEnum.Manual_phase1.ToString(),()=>  CheckN2PurgePhase1() },
                {N2PurgeModeEnum.Manual_phase2.ToString(),()=>  CheckN2PurgePhase2()},
                {N2PurgeModeEnum.Manual_phase3.ToString(),()=>  CheckN2PurgePhase3() },
                {N2PurgeModeEnum.Manual_phase4.ToString(),()=>  CheckN2PurgePhase4() },
                {N2PurgeModeEnum.Manual_phase5.ToString(),()=>  CheckN2PurgePhase5() },

            };
            _allTimeDict = new Dictionary<string, Stopwatch>()
            {
                {N2PurgeModeEnum.Manual_phase1.ToString(),new Stopwatch() },
                {N2PurgeModeEnum.Manual_phase2.ToString(),new Stopwatch()},
                {N2PurgeModeEnum.Manual_phase3.ToString(),new Stopwatch()},
                {N2PurgeModeEnum.Manual_phase4.ToString(),new Stopwatch() },
                {N2PurgeModeEnum.Manual_phase5.ToString(),new Stopwatch() }
            };
            _rTrigDict = new Dictionary<string, R_TRIG>();
        }

        private void MonitorN2Purge()
        {
            var selectN2PurgeMode = SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : "";
            if (string.IsNullOrEmpty(selectN2PurgeMode))
            {
                return;
            }
            SetN2PurgeModeAction(selectN2PurgeMode);
        }
        private double GetN2PurgeLimitData()
        {
            if (_N2PurgeMode == N2PurgeModeEnum.N2PurgeMode)
            {
                if ((SensorO2DetectSideFIMS1 != null && SensorO2DetectSideFIMS1.Value) || (SensorO2DetectSideFIMS2 != null && SensorO2DetectSideFIMS2.Value))
                {
                    return (float)SC.GetValue<double>("PM1.N2Purge.N2PurgeFOUPO2CheckSV");

                }
                return _n2PurgeData;
            }
            if (_N2PurgeMode == N2PurgeModeEnum.ATMMode)
            {
                return _n2ToAirData;
            }
       
            return ConcentrationO2.Value;
        }
        private void SetN2PurgeModeAction(string selectN2PurgeMode)
        {

            _N2PurgeMode = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), selectN2PurgeMode);

            if (_N2PurgeMode == N2PurgeModeEnum.N2PurgeMode)
            {
                if (_currentPhase == N2PurgeModeEnum.Manual_phase1)
                {
                    if (CheckN2PurgePhase2() && _canSwitchToPhase2)
                    {
                        LOG.Info($" N2PurgeMode Trigger from Manual_phase1 to Manual_phase2,O2：{ConcentrationO2.Value}");
                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase2.ToString());
                    }
                }
                else if (_currentPhase == N2PurgeModeEnum.Manual_phase2)
                {
                    if (!_allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].IsRunning && _canSwitchToPhase2)
                    {
                        _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Restart();
                    }
                    var second = _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Elapsed.TotalSeconds;
                    if (second >= _manualPhase2StabilityTime)
                    {
                        if (CheckN2PurgePhase1())
                        {
                            LOG.Info($"N2PurgeMode Trigger Manual_phase1 was triggered {second} seconds later,O2：{ConcentrationO2.Value}");
                            N2PurgeFaileAlarm.Set();

                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Restart();
                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Stop();
                            _canSwitchToPhase2 = false;

                            SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase1.ToString());

                        }
                        if (CheckN2PurgePhase2())
                        {
                            LOG.Info($"N2PurgeMode Trigger Hold Manual_phase2 was triggered {second} seconds later,O2：{ConcentrationO2.Value}");
                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Restart();
                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Stop();
                            _canSwitchToPhase2 = false;
                        }
                    }

                }
                else
                {
                    if (CheckN2PurgePhase1())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase1,O2：{ConcentrationO2.Value}");
                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase1.ToString());
                    }
                    else if (CheckN2PurgePhase2())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase2,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase2.ToString());

                    }
                }
            }
            if (_N2PurgeMode == N2PurgeModeEnum.ATMMode)
            {

                if (_currentPhase == N2PurgeModeEnum.Manual_phase3)
                {
                    var checkResult = CheckN2PurgePhase4();

                    if (!_allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].IsRunning)
                    {
                        _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Restart();
                    }
                    var second = _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Elapsed.TotalSeconds;

                    if (second >= _manualPhase4StabilityTime && checkResult)
                    {
                        LOG.Info($"N2PurgeMode Trigger from  Manual_phase3 to Manual_phase4 is triggered {second} seconds later,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase4.ToString());
                        _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Restart();
                        _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Stop();
                    }

                }
                else if (_currentPhase == N2PurgeModeEnum.Manual_phase4)
                {
                    if (CheckN2PurgePhase5())
                    {
                        LOG.Info($"N2PurgeMode Trigger from Manual_phase4 to Manual_phase5,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase5.ToString());
                    }
                    //if (CheckN2PurgePhase3( ))
                    //{
                    //    LOG.Info($"N2PurgeMode Trigger from Manual_phase4 to Manual_phase3,O2：{o2Value}");

                    //    SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase3.ToString());
                    //}

                }
                else if (_currentPhase == N2PurgeModeEnum.Manual_phase5)
                {
                    if (CheckN2PurgePhase4())
                    {
                        LOG.Info($"N2PurgeMode Trigger from Manual_phase5 to Manual_phase4,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase4.ToString());
                    }
                    //if (CheckN2PurgePhase3( ))
                    //{
                    //    LOG.Info($"N2PurgeMode Trigger from Manual_phase5 to Manual_phase3,O2：{o2Value}");

                    //    SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase3.ToString());
                    //}
                }
                else
                {
                    if (CheckN2PurgePhase3())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase3,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase3.ToString());
                        return;
                    }
                    if (CheckN2PurgePhase5())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase5,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase5.ToString());
                        return;
                    }
                    if (CheckN2PurgePhase4())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase4,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase4.ToString());
                        return;
                    }
                }
            }
            if (_N2PurgeMode == N2PurgeModeEnum.ManualMode || _N2PurgeMode == N2PurgeModeEnum.Auto)
            {
                _currentPhase = _N2PurgeMode;
            }
            //switch (_N2PurgeMode)
            //{
            //    case N2PurgeModeEnum.Auto:
            //        // 自动模式下的操作
            //        break;
            //    case N2PurgeModeEnum.ManualMode:
            //        break;
            //    case N2PurgeModeEnum.N2PurgeMode:

            //        ProcessPhase(_trigN2UpRD, N2PurgeModeEnum.Manual_phase1.ToString());
            //        ProcessPhase(_trigN2DownRD, N2PurgeModeEnum.Manual_phase2.ToString(), _manualPhase2NeedCheck, (int)(_manualPhase2StabilityTime * 1000));
            //        break;
            //    case N2PurgeModeEnum.ATMMode:

            //        ProcessPhase(_trigN2AirDownRD, N2PurgeModeEnum.Manual_phase3.ToString());
            //        ProcessPhase(_trigN2AirUpRD, N2PurgeModeEnum.Manual_phase4.ToString(), _manualPhase4NeedCheck, (int)(_manualPhase4StabilityTime * 1000));
            //        ProcessPhase(_trigN2AirDownTwoRD, N2PurgeModeEnum.Manual_phase5.ToString());
            //        break;
            //}

        }
        bool CheckConditionInTime(string modeKey, int millisecondsTimeout, Func<bool> condition)
        {
            var stopwatch = _allTimeDict[modeKey];
            if (!_allTimeDict[modeKey].IsRunning)
            {
                _allTimeDict[modeKey].Restart();
            }
            while (stopwatch.ElapsedMilliseconds < millisecondsTimeout)
            {
                if (!_allTimeDict[modeKey].IsRunning)
                {
                    return true;
                }
                if (!condition())
                {
                    _allTimeDict[modeKey].Stop();
                    _allTimeDict[modeKey].Reset();
                    return false;
                }
            }
            if (stopwatch.ElapsedMilliseconds > millisecondsTimeout)
            {
                _allTimeDict[modeKey].Stop();
                _allTimeDict[modeKey].Reset();
            }
            return true;
        }
        private void ProcessPhase(R_TRIG r_TRIG, string modeKey, bool needCheck = false, int time = 0)
        {
            r_TRIG.CLK = needCheck ? (CheckConditionInTime(modeKey, time, () => _n2PurgeSequenceStatus[modeKey].Invoke())) : _n2PurgeSequenceStatus[modeKey].Invoke();
            if (r_TRIG.Q)
            {
                LOG.Info($"N2PurgeMode Trigger {modeKey}!,O2：{ConcentrationO2.Value},time:{_allTimeDict[modeKey].ElapsedMilliseconds}");
                SetN2PurgeValveData(modeKey);
                _allTimeDict[modeKey].Stop();
                _allTimeDict[modeKey].Reset();
            }
        }
        public void RestAllN2PrugeRD()
        {
            _trigN2AirDownRD.RST = false;
            _trigN2AirUpRD.RST = false;
            _trigN2DownRD.RST = false;
            _trigN2UpRD.RST = false;

            foreach (var item in _allTimeDict)
            {
                item.Value.Stop();
                item.Value.Reset();
            }
            _canSwitchToPhase2 = true;
        }
        private void SetN2PurgeValveData(string mode, string msg = "")
        {

            var value = _n2PurgeSequenceAction[mode];

            _currentPhase = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), mode);

            if (SC.ContainsItem("PM1.SelectN2PurgeModePhase"))
            {
                SC.SetItemValue("PM1.SelectN2PurgeModePhase", mode);
            }
            foreach (var operateItem in value.Item2)
            {
                if (operateItem.Item1 is IoMFC)
                {
                    var ioMFc = (operateItem.Item1 as IoMFC);
                    { ioMFc.SetMfcValue(out _, 0, new object[] { float.Parse(operateItem.Item2.ToString()) }); }
                }

                if (operateItem.Item1 is IoValve)
                {
                    var ioValve = (operateItem.Item1 as IoValve);

                    ioValve.TurnValve(bool.Parse(operateItem.Item2), out _);
                }
                if (operateItem.Item1 is IoTrigger)
                {
                    var ioTrigger = (operateItem.Item1 as IoTrigger);

                    ioTrigger.CheckAndSet(bool.Parse(operateItem.Item2), out _);
                }
            }


        }

        private bool SetN2PurgeMode(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            var mode = param[0].ToString();
            _N2PurgeMode = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), mode);

            if (SC.ContainsItem("PM1.SelectN2PurgeMode"))
            {
                SC.SetItemValue("PM1.SelectN2PurgeMode", mode);
            }
            RestAllN2PrugeRD();
            return true;
        }

        /// <summary>
        /// 获取当前O2检测位置的设定值
        /// </summary>
        /// <returns></returns>
        private string GetO2SetCheckSetPoint()
        {
            if (SensorO2DetectSideLA != null && SensorO2DetectSideLA.Value)
            {
                var key = "PM1.N2Purge.N2PurgeLAO2CheckSV";
                if (SC.ContainsItem(key))
                    return SC.GetValue<double>(key).ToString("f3");
            }

            if ((SensorO2DetectSideFIMS1 != null && SensorO2DetectSideFIMS1.Value) || (SensorO2DetectSideFIMS2 != null && SensorO2DetectSideFIMS2.Value))
            {
                var key = "PM1.N2Purge.N2PurgeFOUPO2CheckSV";
                if (SC.ContainsItem(key))
                    return SC.GetValue<double>(key).ToString("f3");
            }
            return "";
        }
        /// <summary>
        /// 获取当前O2检测位置
        /// </summary>
        /// <returns></returns>
        private string GetCheckO2Location()
        {
            if (SensorO2DetectSideLA != null && SensorO2DetectSideLA.Value)
                return SensorO2DetectSideLA.Display;

            if (SensorO2DetectSideFIMS1 != null && SensorO2DetectSideFIMS1.Value)
                return SensorO2DetectSideFIMS1.Display;

            if (SensorO2DetectSideFIMS2 != null && SensorO2DetectSideFIMS2.Value)
                return SensorO2DetectSideFIMS2.Display;

            return "";
        }
        /// <summary>
        /// 获取当前O2浓度
        /// </summary>
        /// <returns></returns>


        private bool CheckN2PurgePhase1()
        {
            return ((int)ConcentrationO2.Value >= _n2PurgeData) && GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase2()
        {
            return ((int)ConcentrationO2.Value < _n2PurgeData) && GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase3()
        {
            return ((int)ConcentrationO2.Value) < _n2ToAirData && GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase5()
        {
            return ((int)ConcentrationO2.Value) >= _n2ToAirData && !GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase4()
        {

            return (((int)ConcentrationO2.Value)) >= _n2ToAirData && GetLADoorOpenStatus();
        }
        private bool GetN2PurgeAIRTo20PPMStatus()
        {
            return ValveAV202.DOOpen.Value;
        }
        private bool GetN2PurgeUnder20PPMStatus(double value = 20)
        {

            return ConcentrationO2.Value < value;
        }
        private bool GetN2PurgeAIRStatus()
        {
            return ValveAV202.DOClose.Value && (AlarmSignalFilterBox1DoorSwitch != null ? !AlarmSignalFilterBox1DoorSwitch.Value : false);
        }
        private bool GetLADoorOpenStatus()
        {
            return (bool)(SensorLADoorSw1?.Value);
        }
        private bool GetN2PurgeDoorOpenStatus()
        {
            return ValveAV202.DOClose.Value && (AlarmSignalFilterBox1DoorSwitch != null ? !AlarmSignalFilterBox1DoorSwitch.Value : false);
        }
        private bool GetN2PurgeFoup1Status()
        {
            return GetN2PurgeAIRTo20PPMStatus() && GetN2PurgeUnder20PPMStatus() && FIMS1.IsFoupExist && FIMS1.CollisionAvoidanceUpDownStatus == DeviceStatus.Down;
        }
        private bool GetN2PurgeFoup2Status()
        {
            return GetN2PurgeAIRTo20PPMStatus() && GetN2PurgeUnder20PPMStatus() && FIMS2.IsFoupExist && FIMS2.CollisionAvoidanceUpDownStatus == DeviceStatus.Down; ;
        }
        public bool IsAbortN2purge()
        {
            if (!_enableAbortN2purge)
            {
                return false;
            }

            if (SensorSL02001gasboxdoorsw11.Value || SensorSL02001gasboxdoorsw12.Value || SensorSL02002gasboxdoorsw11.Value || SensorSL02002gasboxdoorsw12.Value || SensorSL05002LAdoorsw2.Value || SensorSL05004LAfurnacedoorsw.Value)
            {
                return true;
            }


            return false;

        }

        public void SetN2PurgeLAO2CheckFirstEnable(bool isEable)
        {
            if (TrigN2PurgeLAO2CheckFirstEnable != null && TrigN2PurgeLAO2CheckFirstEnable.Value != isEable)
            {
                TrigN2PurgeLAO2CheckFirstEnable.SetTrigger(isEable, out _);
            }
        }
        public void SetN2PurgeFIMS1O2CheckEnable(ModuleName fims, bool isEable)
        {
            if (fims == ModuleName.FIMS1 && TrigN2PurgeFIMS1O2CheckEnable != null && TrigN2PurgeFIMS1O2CheckEnable.Value != isEable)
            {
                TrigN2PurgeFIMS1O2CheckEnable.SetTrigger(isEable, out _);
            }

            if (fims == ModuleName.FIMS2 && TrigN2PurgeFIMS2O2CheckEnable != null && TrigN2PurgeFIMS2O2CheckEnable.Value != isEable)
            {
                TrigN2PurgeFIMS2O2CheckEnable.SetTrigger(isEable, out _);

            }
        }
        public void SetN2PurgeProcess(bool isEable)
        {
            if (TrigN2PurgeProcess != null && TrigN2PurgeProcess.Value != isEable)
            {
                TrigN2PurgeProcess.SetTrigger(isEable, out _);
            }
        }
        public void SetN2PurgeLAO2CheckSV(float value)
        {
            if (TrigN2PurgeLAO2CheckSV != null)
                TrigN2PurgeLAO2CheckSV?.SetAOTrigger(value, out _);
        }
        public void SetN2PurgeFOUPO2CheckSV(float value)
        {
            if (TrigN2PurgeFOUPO2CheckSV != null)
                TrigN2PurgeFOUPO2CheckSV?.SetAOTrigger(value, out _);
        }
        public bool FIMSLoadCheckLAO2(out string reason)
        {
            var scLAO2 = (float)SC.GetValue<double>("PM1.N2Purge.N2PurgeLAO2CheckSV");
            reason = $"LA O2 concentration has not reached below {scLAO2}ppm";
            if (SensorO2DetectSideLA == null || !SensorO2DetectSideLA.Value)
            {
                reason = $"Oxygen analyzer not switched to LA";
                return false;
            }

            return ((int)(ConcentrationO2.Value)) < scLAO2;
        }
        public void SetAVParameter(ModuleName fims, bool isEable)
        {
            if (fims == ModuleName.FIMS1)
            {
                var avValve58 = DEVICE.GetDevice<IoValve>($"{ModuleName.PM1}.ValveAV58");
                avValve58?.TurnValve(isEable, out _);
            }

            if (fims == ModuleName.FIMS2)
            {
                var avValve59 = DEVICE.GetDevice<IoValve>($"{ModuleName.PM1}.ValveAV59");
                avValve59?.TurnValve(isEable, out _);
            }

        }
        /// <summary>
        /// N2Purge相关时间参数，电气要求设定为秒，实际下发按照毫秒
        /// </summary>
        public void SetN2PurgeParameters()
        {
            if (SC.ContainsItem("PM1.N2Purge.TransferRoomArrivalWaitTime") && TrigN2PurgeLAO2CheckTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.TransferRoomArrivalWaitTime");
                TrigN2PurgeLAO2CheckTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.TransferRoomStableWaitTime") && TrigN2PurgeLAO2OverTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.TransferRoomStableWaitTime");
                TrigN2PurgeLAO2OverTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.FOUPOpenerArrivalWaitTime") && TrigN2PurgeFOUPO2CheckTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.FOUPOpenerArrivalWaitTime");
                TrigN2PurgeFOUPO2CheckTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.FOUPOpenerStableWaitTime") && TrigN2PurgeFOUPO2OverTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.FOUPOpenerStableWaitTime");
                TrigN2PurgeFOUPO2OverTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.O2DetectorTransferRoomToFOUPTime") && TrigN2PurgeExchangeLATOFOUPWaitTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.O2DetectorTransferRoomToFOUPTime");
                TrigN2PurgeExchangeLATOFOUPWaitTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.O2DetectorFOUPToTransferRoomTime") && TrigN2PurgeExchangeFOUPTOLAWaitTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.O2DetectorFOUPToTransferRoomTime");
                TrigN2PurgeExchangeFOUPTOLAWaitTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.O2DetectorFOUPToFOUPTime") && TrigN2PurgeExchangeFOUPTOFOUPWaitTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.O2DetectorFOUPToFOUPTime");
                TrigN2PurgeExchangeFOUPTOFOUPWaitTime.SetAOTrigger(time, out _);
            }
            SetN2PurgeLAO2CheckSV((float)SC.GetValue<double>("PM1.N2Purge.N2PurgeLAO2CheckSV"));
            SetN2PurgeFOUPO2CheckSV((float)SC.GetValue<double>("PM1.N2Purge.N2PurgeFOUPO2CheckSV"));
        }

        public void InitN2PurgeMode(string n2PurgeModeStr, bool isN2Purge)
        {
            if (SC.ContainsItem("PM1.RecipeRelevancyN2Purge") && SC.GetValue<bool>("PM1.RecipeRelevancyN2Purge") && SC.ContainsItem("PM1.SelectN2PurgeMode"))
            {
                if (!isN2Purge)
                {
                    SC.SetItemValueFromString("PM1.SelectN2PurgeMode", N2PurgeModeEnum.ManualMode.ToString());
                }
                else
                {
                    var setValue = GetN2PurgeModeEnumByStr(n2PurgeModeStr);
                    SC.SetItemValueFromString("PM1.SelectN2PurgeMode", setValue);
                }
                RestAllN2PrugeRD();
            }
        }
    }
}