using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Simulator.Core.Driver;
using System;
using System.Collections.Generic;
using VirgoSimulator.Devices;

namespace VirgoSimulator.Instances
{
    public class SimulatorSystem : Singleton<SimulatorSystem>
    {
        private PeriodicJob _thread;

        private Random _rd = new Random();

        private RD_TRIG _trigATM = new RD_TRIG();
        private RD_TRIG _trigVAC = new RD_TRIG();

        private readonly float ATM_THRESHOLD = 750000;
        private readonly float ATM_PRESSURE = 760000;
        private readonly uint VAC_SW_PRESSURE = 9500;
        private readonly uint PROCESS_GAUGE = 10000;

        private Dictionary<ModuleName, DeviceSimulator> _MockDevices = new Dictionary<ModuleName, DeviceSimulator>();

        public SimulatorSystem()
        {
            //_MockDevices.Add(ModuleName.PMB, new SkyPumpMock());
            //_MockDevices.Add(ModuleName.PMB, new AdTecGeneratorMock());
            //_MockDevices.Add(ModuleName.PMB, new AdTecMatchMock());

            // TODO
        }

        ~SimulatorSystem()
        {
            _thread?.Stop();
        }

        public void Initialize()
        {
            SetDefaultValue(ModuleName.PMA);
            SetDefaultValue(ModuleName.PMB);

            Singleton<DataManager>.Instance.Initialize(false);

            _thread = new PeriodicJob(500, OnMonitor, nameof(SimulatorSystem), true);
        }

        private void SetDefaultValue(ModuleName mod)
        {
            // chamber
            IO.DI[$"{mod}.DI_Lid_Closed"].Value = true;
            IO.DI[$"{mod}.DI_PM_ATM_SW"].Value = true;
            IO.DI[$"{mod}.DI_CDA_Pressure"].Value = true;
            IO.DI[$"{mod}.DI_SourceFan1"].Value = true;
            IO.DI[$"{mod}.DI_SourceFan2"].Value = true;
            IO.DI[$"{mod}.DI_Cooling_Water_Flow_SW"].Value = true;
            IO.DI[$"{mod}.DI_Coolant_Inlet_TC_Broken_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_Coolant_Outlet_TC_Broken_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_Water_Leak"].Value = true;
            IO.DI[$"{mod}.DI_ARM_Not_Extend_to_PM"].Value = true;
            IO.DI[$"{mod}.DI_MFC1_Pressure"].Value = true;
            IO.DI[$"{mod}.DI_MFC2_Pressure"].Value = true;
            IO.DI[$"{mod}.DI_MFC3_Pressure"].Value = true;
            IO.DI[$"{mod}.DI_MFC4_Pressure"].Value = true;
            IO.DI[$"{mod}.DI_MFC5_Pressure"].Value = true;
            IO.DI[$"{mod}.DI_EFEM_Side_Panel_Closed"].Value = true;
            IO.DI[$"{mod}.DI_Generator_Hardware_Interlock"].Value = true;
            IO.DI[$"{mod}.DI_N2_Pressure"].Value = true;
            // slit door
            IO.DI[$"{mod}.DI_Slit_Door_Open_Pos"].Value = false;
            IO.DI[$"{mod}.DI_Slit_Door_Close_Pos"].Value = true;

            // lift pin
            IO.DI[$"{mod}.DI_Lift_Pin_Up"].Value = false;
            IO.DI[$"{mod}.DI_Lift_Pin_Down"].Value = true;
            //
            IO.DI[$"{mod}.DI_LE_OT_SW_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_GB_Door_SW_Alarm"].Value = false;
            IO.DI[$"{mod}.DI_GB_Pressure_SW_Alarm"].Value = false;
            //Guide pin
            IO.DI[$"{mod}.DI_Guide_Pin_Small_Lifter_Up_Pos"].Value = false;
            IO.DI[$"{mod}.DI_Guide_Pin_Small_Lifter_Down_Pos"].Value = true;
            IO.DI[$"{mod}.DI_Guide_Pin_Medium_Lifter_Up_Pos"].Value = false;
            IO.DI[$"{mod}.DI_Guide_Pin_Medium_Lifter_Down_Pos"].Value = true;

            IO.DI[$"{mod}.DI_Dry_Pump_Running"].Value = false;
            IO.DI[$"{mod}.DI_Pump_Remote_Status"].Value = true;
            IO.DI[$"{mod}.DI_Pump_Alarm"].Value = false;


            // pressure
            SetAiValue($"{mod}.AI_Foreline_pressure", 5000);
            SetAiValue($"{mod}.AI_Chamber_pressure", ATM_PRESSURE);
            SetAiValue($"{mod}.AI_Process_pressure", PROCESS_GAUGE);
            //SetAiValue($"{mod}.AI_Throttle_Valve_State", 1);
            IO.AI[$"{mod}.AI_Throttle_Valve_State"].Value = 1;
            IO.AI[$"{mod}.AI_Throttle_Valve_Real_Position"].Value = 10;

            // Temperature
            SetAiValue($"{mod}.AI_Substrate_Control_TC_Temp", 28);
            SetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp", 27);
            SetAiValue($"{mod}.AI_Foreline_Control_TC_Temp", 28);
            SetAiValue($"{mod}.AI_Foreline_Monitor_TC_Temp", 27);
            SetAiValue($"{mod}.AI_Coolant_Inlet_Temp", 28);
            if (mod == ModuleName.PMA)
            {
                SetAiValue($"{mod}.AI_Coolant_Outlet_Temp", 29);
            }
            else if (mod == ModuleName.PMB)
            {
                SetAiValue($"{mod}.AI_Coolant_Outlet_Temp", 30);
            }
            // Datetime
            SetAiValue($"{mod}.AI_Year", DateTime.Today.Year);
            SetAiValue($"{mod}.AI_Month", DateTime.Today.Month);
            SetAiValue($"{mod}.AI_Day", DateTime.Today.Day);
        }

        private bool OnMonitor()
        {
            try
            {
                // PMA
                MonitorSlitDoor(ModuleName.PMA);
                MonitorPin(ModuleName.PMA);
                MonitorPressure(ModuleName.PMA);
                MonitorTemperature(ModuleName.PMA);
                MonitorGas(ModuleName.PMA);
                MonitorRF(ModuleName.PMA);
                ChangeTime(ModuleName.PMA);
                MonitorIOPumpCtrl(ModuleName.PMA);

                // PMB
                MonitorSlitDoor(ModuleName.PMB);
                MonitorPin(ModuleName.PMB);
                MonitorPressure(ModuleName.PMB);
                MonitorTemperature(ModuleName.PMB);
                MonitorGas(ModuleName.PMB);
                MonitorRF(ModuleName.PMB);
                ChangeTime(ModuleName.PMB);
                MonitorIOPumpCtrl(ModuleName.PMB);
            }
            catch (Exception e)
            {
                LOG.Write(e);
            }
            return true;
        }

        private void ChangeTime(ModuleName mod)
        {
            // Heartbeat with PLC
            SetAiValue($"{mod}.AI_Heartbeat_FB", GetAoValue($"{mod}.AO_Heartbeat"));

            SetAiValue($"{mod}.AI_Time", DateTime.Now.Hour);
            SetAiValue($"{mod}.AI_Minute", DateTime.Now.Minute);
            SetAiValue($"{mod}.AI_Second", DateTime.Now.Second);
        }

        void MonitorSlitDoor(ModuleName mod)
        {
            // slit door open
            if (IO.DO[$"{mod}.DO_Slit_Door_Open"].Value)
            {
                IO.DI[$"{mod}.DI_Slit_Door_Open_Pos"].Value = true;
                IO.DI[$"{mod}.DI_Slit_Door_Close_Pos"].Value = false;
            }

            // slit door close
            if (IO.DO[$"{mod}.DO_Slit_Door_Close"].Value)
            {
                IO.DI[$"{mod}.DI_Slit_Door_Open_Pos"].Value = false;
                IO.DI[$"{mod}.DI_Slit_Door_Close_Pos"].Value = true;
            }
        }

        void MonitorPin(ModuleName mod)
        {
            // lift pin up
            if (IO.DO[$"{mod}.DO_Lift_Pin_Up"].Value != IO.DO[$"{mod}.DO_Lift_Pin_Down"].Value)
            {
                IO.DI[$"{mod}.DI_Lift_Pin_Up"].Value = IO.DO[$"{mod}.DO_Lift_Pin_Up"].Value;
                IO.DI[$"{mod}.DI_Lift_Pin_Down"].Value = IO.DO[$"{mod}.DO_Lift_Pin_Down"].Value;
            }

            // upper guide pin up
            if (IO.DO[$"{mod}.DO_Guide_Pin_Small_Lifter_Up"].Value)
            {
                IO.DI[$"{mod}.DI_Guide_Pin_Small_Lifter_Up_Pos"].Value = true;
                IO.DI[$"{mod}.DI_Guide_Pin_Small_Lifter_Down_Pos"].Value = false;
            }

            // upper guide pin down
            if (IO.DO[$"{mod}.DO_Guide_Pin_Small_Lifter_Down"].Value)
            {
                IO.DI[$"{mod}.DI_Guide_Pin_Small_Lifter_Up_Pos"].Value = false;
                IO.DI[$"{mod}.DI_Guide_Pin_Small_Lifter_Down_Pos"].Value = true;
            }

            // lower guide pin up
            if (IO.DO[$"{mod}.DO_Guide_Pin_Medium_Lifter_Up"].Value)
            {
                IO.DI[$"{mod}.DI_Guide_Pin_Medium_Lifter_Up_Pos"].Value = true;
                IO.DI[$"{mod}.DI_Guide_Pin_Medium_Lifter_Down_Pos"].Value = false;
            }

            // lower guide pin down
            if (IO.DO[$"{mod}.DO_Guide_Pin_Medium_Lifter_Down"].Value)
            {
                IO.DI[$"{mod}.DI_Guide_Pin_Medium_Lifter_Up_Pos"].Value = false;
                IO.DI[$"{mod}.DI_Guide_Pin_Medium_Lifter_Down_Pos"].Value = true;
            }
        }

        void MonitorPressure(ModuleName mod)
        {
            // pressure
            string sAI_Foreline = "AI_Foreline_pressure";
            // Foreline

            if (SkyPumpMockPMA._simPumpStatus == SkyPumpMockPMA.SimPumpStatus.Open || EdwardsPumpMockPMA._simPumpStatus == EdwardsPumpMockPMA.SimEdwardsPumpStatus.Open)
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") - _rd.Next(500, 600));
            }
            else
            {
                SetAiValue($"{mod}.{sAI_Foreline}", GetAiValue($"{mod}.{sAI_Foreline}") + _rd.Next(500, 600));
            }

            // PLC 模拟量范围[0，4000], 电压[0, 10V], 压力[0, 760Torr]
            string sAI_ChamberPressure = "AI_Chamber_pressure";
            string sAI_ProcessPressure = "AI_Process_pressure";
            //float chamber_pressure = GetMockChamberPressure(mod);
            //float process_pressure = GetAiValue($"{mod}.AI_Process_pressure");

            // soft pump & fast pump
            DOAccessor fast_pump_vlv = IO.DO[$"{mod}.DO_Fast_Pumping_Valve"];
            DOAccessor soft_pump_vlv = IO.DO[$"{mod}.DO_Soft_Pumping_Valve"];

            if (fast_pump_vlv.Value || soft_pump_vlv.Value)
            {
                if (fast_pump_vlv.Value && soft_pump_vlv.Value)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - 30000);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1500);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1500);
                    }

                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(15000, 16000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(150, 160));
                }
                else if (fast_pump_vlv.Value)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - 25000);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1300);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1300);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(12000, 13000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(120, 130));
                }
                else if (soft_pump_vlv.Value)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - 22000);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1100);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 1100);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") - _rd.Next(13000, 14000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - _rd.Next(100, 110));
                }
            }

            // fast vent & purge
            DOAccessor vent_vlv = IO.DO[$"{mod}.DO_Chamber_vent_valve"];
            DOAccessor purge_vlv = IO.DO[$"{mod}.DO_Chamber_purge_valve"];

            if (vent_vlv.Value || purge_vlv.Value)
            {
                if (vent_vlv.Value && purge_vlv.Value)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 30000);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1500);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1500);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(45000, 50000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(150, 160));
                }
                else if (vent_vlv.Value)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");
                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 25000);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 1300);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(25000, 30000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(130, 150));
                }
                else if (purge_vlv.Value)
                {
                    float getAiValue_ChamberPressure = GetAiValue($"{mod}.{sAI_ChamberPressure}");
                    float getAiValue_ProcessPressure = GetAiValue($"{mod}.{sAI_ProcessPressure}");

                    if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure > 10000)
                    {
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + 30000);
                        //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") - 150);
                    }
                    else if (getAiValue_ProcessPressure <= 10000 && getAiValue_ChamberPressure <= 10000)
                    {
                        getAiValue_ProcessPressure = getAiValue_ChamberPressure;
                        SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 3100);
                        SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + 3100);
                    }
                    //SetAiValue($"{mod}.{sAI_ChamberPressure}", GetAiValue($"{mod}.{sAI_ChamberPressure}") + _rd.Next(15000, 20000));
                    //SetAiValue($"{mod}.{sAI_ProcessPressure}", GetAiValue($"{mod}.{sAI_ProcessPressure}") + _rd.Next(100, 120));
                }
            }

            // 压力值越界，复位
            float chamber_pressure1 = GetAiValue($"{mod}.{sAI_ChamberPressure}");
            if (chamber_pressure1 > ATM_PRESSURE)
            {
                SetAiValue($"{mod}.AI_Chamber_pressure", ATM_PRESSURE);
            }
            else if (chamber_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Chamber_pressure", 20);
            }

            float process_pressure1 = GetAiValue($"{mod}.{sAI_ProcessPressure}");
            if (process_pressure1 > PROCESS_GAUGE)
            {
                SetAiValue($"{mod}.AI_Process_pressure", PROCESS_GAUGE);
            }
            else if (process_pressure1 < 20)
            {
                SetAiValue($"{mod}.AI_Process_pressure", 20);
            }

            float foreline_pressure = GetAiValue($"{mod}.{sAI_Foreline}");
            if (foreline_pressure > 10000)
            {
                SetAiValue($"{mod}.AI_Foreline_pressure", 10000);
            }
            else if (foreline_pressure < 150)
            {
                SetAiValue($"{mod}.AI_Foreline_pressure", 150);
            }


            // 模拟压力计漂移
            //int p1 = (int)GetMockChamberPressure(mod);
            //int new_p1 = _rd.Next(p1 - 2, p1 + 2);
            //SetAiValue($"{mod}.AI_Chamber_pressure", new_p1);

            //int p2 = (int)GetAiValue($"{mod}.AI_Foreline_pressure");
            //int new_p2 = _rd.Next(p2 - 1, p2 + 1);
            //SetAiValue($"{mod}.AI_Foreline_pressure", new_p2);

            //int p3 = (int)GetAiValue($"{mod}.AI_Process_pressure");
            //int new_p3 = _rd.Next(p3 - 1, p3 + 1);
            //SetAiValue($"{mod}.AI_Process_pressure", new_p3);

            // 根据当前压力值设定信号
            //float chamber_pressure2 = GetMockChamberPressure(mod);

            // ATM switch
            IO.DI[$"{mod}.DI_PM_ATM_SW"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") > ATM_THRESHOLD;

            // VAC switch
            IO.DI[$"{mod}.DI_PM_VAC_SW"].Value = GetAiValue($"{mod}.{sAI_ChamberPressure}") < VAC_SW_PRESSURE;

            // Throttle valve

            //var pos_sp = IO.AO[$"{mod}.AO_Throttle_Valve_Pressure_Setpoint"].Value;
            //var mock_pos_fb = _rd.Next(pos_sp - 2, pos_sp + 2);
            ////IO.AI[$"{mod}.AI_Throttle_Valve_Real_Pressure"].Value = (short)mock_pos_fb;
            //SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", mock_pos_fb);

            // 压力值
            if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") < GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"))
            {
                short increase = (short)_rd.Next(20, 30);
                SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") + increase);
                if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") > GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"))
                {
                    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"));
                }
            }
            else
            {
                short increase = (short)_rd.Next(20, 30);

                SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") - increase);
                if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure") < GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"))
                {
                    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Pressure", GetAoValue($"{mod}.AO_Throttle_Valve_Pressure_Setpoint"));
                }
            }

            // 位置值
            if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") < GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"))
            {
                short increase = (short)_rd.Next(20, 30);
                SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") + increase);
                if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") > GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"))
                {
                    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"));
                }
            }
            else
            {
                short increase = (short)_rd.Next(20, 30);

                SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") - increase);
                if (GetAiValue($"{mod}.AI_Throttle_Valve_Real_Position") < GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"))
                {
                    SetAiValue($"{mod}.AI_Throttle_Valve_Real_Position", GetAoValue($"{mod}.AO_Throttle_Valve_Position_Setpoint"));
                }
            }
        }

        //float GetMockChamberPressure(ModuleName mod)
        //{
        //    return GetAiValue($"{mod}.AI_Chamber_pressure");
        //}

        //void SetMockChamberPressure(ModuleName mod, float val)
        //{
        //    SetAiValue($"{mod}.AI_Chamber_pressure", val);
        //}

        void SetAiValue(string name, float value)
        {
            byte[] flow = BitConverter.GetBytes(value);
            short high1 = BitConverter.ToInt16(flow, 0);
            short low1 = BitConverter.ToInt16(flow, 2);

            IO.AI[name].Buffer[IO.AI[name].Index] = BitConverter.ToInt16(flow, 0);
            IO.AI[name].Buffer[IO.AI[name].Index + 1] = BitConverter.ToInt16(flow, 2);

            byte[] high = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index]);
            byte[] low = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index + 1]);
            float readback = BitConverter.ToSingle(new[] { high[0], high[1], low[0], low[1] }, 0);
        }

        float GetAiValue(string name)
        {
            byte[] high = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index]);
            byte[] low = BitConverter.GetBytes(IO.AI[name].Buffer[IO.AI[name].Index + 1]);
            float flow = BitConverter.ToSingle(new[] { high[0], high[1], low[0], low[1] }, 0);
            return flow;
        }

        float GetAoValue(string name)
        {
            byte[] high = BitConverter.GetBytes(IO.AO[name].Buffer[IO.AO[name].Index]);
            byte[] low = BitConverter.GetBytes(IO.AO[name].Buffer[IO.AO[name].Index + 1]);
            float flow = BitConverter.ToSingle(new[] { high[0], high[1], low[0], low[1] }, 0);
            return flow;
        }

        void MonitorTemperature(ModuleName mod)
        {
            IO.DI[$"{mod}.DI_Substrate_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_Substrate_Heater_On"].Value;
            IO.DI[$"{mod}.DI_Foreline_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_Forline_Heater_On"].Value;
            IO.DI[$"{mod}.DI_CHB_Wall_Heater_On_FB"].Value = IO.DO[$"{mod}.DO_CHB_Wall_Heater_On"].Value;
            IO.DI[$"{mod}.DI_Foreline_TC_Deviation_out_of_range"].Value = false;
            IO.DI[$"{mod}.DI_Substrate_TC_Deviation_out_of_range"].Value = false;
            // 底座
            if (IO.DO[$"{mod}.DO_Substrate_Heater_On"].Value &&
                GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") < GetAoValue($"{mod}.AO_Substrate_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_Substrate_Control_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") + _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp") + _rd.Next(1, 2));
            }
            else if (IO.DO[$"{mod}.DO_Substrate_Heater_On"].Value &&
                     GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") > GetAoValue($"{mod}.AO_Substrate_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_Substrate_Control_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") - _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Substrate_Monitor_TC_Temp") - _rd.Next(1, 2));
            }

            // Foreline
            if (IO.DO[$"{mod}.DO_Forline_Heater_On"].Value &&
                GetAiValue($"{mod}.AI_Foreline_Control_TC_Temp") < GetAoValue($"{mod}.AO_Foreline_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_Foreline_Control_TC_Temp", GetAiValue($"{mod}.AI_Foreline_Control_TC_Temp") + _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_Foreline_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Foreline_Monitor_TC_Temp") + _rd.Next(1, 2));
            }
            else if (IO.DO[$"{mod}.DO_Forline_Heater_On"].Value &&
                     GetAiValue($"{mod}.AI_Foreline_Control_TC_Temp") > GetAoValue($"{mod}.AO_Foreline_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_Foreline_Control_TC_Temp", GetAiValue($"{mod}.AI_Foreline_Control_TC_Temp") - _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_Foreline_Monitor_TC_Temp", GetAiValue($"{mod}.AI_Foreline_Monitor_TC_Temp") - _rd.Next(1, 2));
            }


            // Wall
            if (IO.DO[$"{mod}.DO_CHB_Wall_Heater_On"].Value &&
                GetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp") < GetAoValue($"{mod}.AO_CHB_Wall_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp") + _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp") + _rd.Next(1, 2));
            }
            else if (IO.DO[$"{mod}.DO_CHB_Wall_Heater_On"].Value &&
                     GetAiValue($"{mod}.AI_Substrate_Control_TC_Temp") > GetAoValue($"{mod}.AO_CHB_Wall_Temperature_Setpoint"))
            {
                SetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Control_TC_Temp") - _rd.Next(1, 2));
                SetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp", GetAiValue($"{mod}.AI_CHB_Wall_Monitor_TC_Temp") - _rd.Next(1, 2));
            }
        }

        void MonitorGas(ModuleName mod)
        {
            // gas
            this.SimulateMFC(ModuleName.PMA, 1);
            this.SimulateMFC(ModuleName.PMA, 2);
            this.SimulateMFC(ModuleName.PMA, 3);
            this.SimulateMFC(ModuleName.PMA, 4);
            this.SimulateMFC(ModuleName.PMA, 5);

            this.SimulateMFC(ModuleName.PMB, 1);
            this.SimulateMFC(ModuleName.PMB, 2);
            this.SimulateMFC(ModuleName.PMB, 3);
            this.SimulateMFC(ModuleName.PMB, 4);
            this.SimulateMFC(ModuleName.PMB, 5);
        }

        private void SimulateMFC(ModuleName mod, byte gasNum)
        {
            var sp = GetAoValue($"{mod}.AO_MFC{gasNum}_Flow_Setpoint");

            if (gasNum == 3)
            {
                sp = Math.Max(0, sp - 1500);
            }

            var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();
            SetAiValue($"{mod}.AI_MFC{gasNum}_Flow", (float)mock_fb);
        }

        void MonitorRF(ModuleName mod)
        {
            // RF generator
            var sp = GetAoValue($"{mod}.AO_Generator_Power_Setpoint");
            var mock_fb = _rd.Next((int)sp - 3, (int)sp + 3) + _rd.NextDouble();

            //var mock_sp = _rd.Next(sp - 3, sp + 3);
            SetAiValue($"{mod}.AI_Generator_Forward_Power", (float)mock_fb);

            //IO.DI[$"{mod}.DI_Generator_Power_Status"].Value = IO.DO[$"{mod}.DO_Generator_Power_ON"].Value;
        }

        void MonitorIOPumpCtrl(ModuleName mod)
        {
            if (IO.DO[$"{mod}.DO_Pump_Run"].Value) IO.DI[$"{mod}.DI_Dry_Pump_Running"].Value = true;
            if (IO.DO[$"{mod}.DO_Pump_Stop"].Value) IO.DI[$"{mod}.DI_Dry_Pump_Running"].Value = false;
        }


        public void Terminate()
        {
            _thread.Stop();
        }
    }
}