#include "SignalService.h"
#include "../config/ConfigManager.h"
//#include "SignalState.h"
#include <chrono>
#include "../Toast.h"
#include "../SystemInfo.h"
#include "../LanguageManager.h"

SignalService::SignalService()
	:m_RunFlag(false)
	, m_LastPLCKeepAlive(false)
{
	m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_IOCfgWrapper = ConfigManager::GetInstance()->GetIoCfgWrapper();
	m_PowderEstimateCfg = ConfigManager::GetInstance()->GetPowderEstimateCfg();
	m_CycleTick = 100;
}

SignalService::~SignalService() {
	m_RunFlag = false;
	if(m_CheckThread.joinable())m_CheckThread.join();
}

void SignalService::RunService() {
	if (m_CheckThread.joinable())return;
	m_RunFlag = true;
	//m_CheckThread = std::thread(&SignalService::CheckProc, this);
}

SignalService& SignalService::GetInstance()
{
	static SignalService instance;
	return instance;
}

void SignalService::SetCoreCommuniction(CoreCommunication* coreCommunication)
{
	m_CoreCommunication = coreCommunication;
}

void SignalService::SetSignalStateCtrl(SignalStateWrapper* signalStateCtrl)
{
	m_SignalStateCtrl = signalStateCtrl;
}
//void SignalService::CheckProc()
//{
//	while (m_RunFlag) {
//		//m_CoreCommunication->GetAlarmState(m_SignalState);
//		std::unique_lock<std::shared_mutex> lock(m_Mtx);
//
//		if (m_CoreCommunication->IsConnect()) {
//			m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm->m_IsAlarm = false;
//		}
//		else {
//			if (m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm->m_AlarmContinueTick++;
//			}
//		}
//
//		//PLC判断连接断开报警
//		//if (m_SignalState.m_PLCConnectAlarm) {
//		//	if (m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm->m_CheckAlarmSetTick) {
//		//		m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm->m_IsAlarm = true;
//		//	}
//		//	else {
//		//		m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm->m_AlarmContinueTick++;
//		//	}
//		//}
//		//else {
//		//	m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm->m_AlarmContinueTick = 0;
//		//	m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm->m_IsAlarm = false;
//		//}
//
//		//if (m_LastPLCKeepAlive == m_SignalState.m_PLCKeepAlive)
//		//{
//		//	if (m_AlarmCfgWrapper->m_PLCKeepaliveAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_PLCKeepaliveAlarm->m_CheckAlarmSetTick)
//		//	{
//		//		m_AlarmCfgWrapper->m_PLCKeepaliveAlarm->m_IsAlarm = true;
//		//	}
//		//	else {
//		//		m_AlarmCfgWrapper->m_PLCKeepaliveAlarm->m_AlarmContinueTick++;
//		//	}
//		//}
//		//else {
//		//	m_AlarmCfgWrapper->m_PLCKeepaliveAlarm->m_AlarmContinueTick = 0;
//		//	m_AlarmCfgWrapper->m_PLCKeepaliveAlarm->m_IsAlarm = false;
//		//}
//		//m_LastPLCKeepAlive = m_SignalState.m_PLCKeepAlive;
//
//		//系统急停
//		//m_AlarmCfgWrapper->m_SystemStopAlarm->m_IsAlarm = m_SignalState.m_SystemStopAlarm;
//
//		//外部断电报警
//		if (m_SignalState.m_PowerDownAlarm) {
//			if (m_AlarmCfgWrapper->m_PowerBreakAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_PowerBreakAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_PowerBreakAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_PowerBreakAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_PowerBreakAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_PowerBreakAlarm->m_IsAlarm = false;
//		}
//
//
//		//激光器冷水机报警
//		if (m_SignalState.m_LaserChillerAlarm) {
//			if (m_AlarmCfgWrapper->m_LaserChillerAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_LaserChillerAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_LaserChillerAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_LaserChillerAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_LaserChillerAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_LaserChillerAlarm->m_IsAlarm = false;
//		}
//
//		//总空开报警
//		if (m_SignalState.m_BusAirSwitchAlarm) {
//			if (m_AlarmCfgWrapper->m_BusAirSwitchAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_BusAirSwitchAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_BusAirSwitchAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_BusAirSwitchAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_BusAirSwitchAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_BusAirSwitchAlarm->m_IsAlarm = false;
//		}
//
//		//外部设备电源空开报警
//		if (m_SignalState.m_ExtDevicePowerAirSwitchAlarm) {
//			if (m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm->m_IsAlarm = false;
//		}
//
//		//加热电源空开报警
//		if (m_SignalState.m_HeatingPowerAirSwitchAlarm) {
//			if (m_AlarmCfgWrapper->m_HeatingPowerAirSwitchAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_HeatingPowerAirSwitchAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_HeatingPowerAirSwitchAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_HeatingPowerAirSwitchAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_HeatingPowerAirSwitchAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_HeatingPowerAirSwitchAlarm->m_IsAlarm = false;
//		}
//
//		//激光电源空开报警
//		if (m_SignalState.m_LaserPowerAirSwitchAlarm) {
//			if (m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm->m_IsAlarm = false;
//		}
//
//		//伺服电源空开报警
//		if (m_SignalState.m_ServoPowerAirSwitchAlarm) {
//			if (m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm->m_IsAlarm = false;
//		}
//
//		if (m_SignalState.m_HighPressureLackAlarm) {
//			if (m_AlarmCfgWrapper->m_HighPressureLackAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_HighPressureLackAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_HighPressureLackAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_HighPressureLackAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_HighPressureLackAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_HighPressureLackAlarm->m_IsAlarm = false;
//		}
//
//
//		m_AlarmCfgWrapper->m_Laser1Alarm->m_IsAlarm = m_SignalState.m_Laser1Alarm;
//		m_AlarmCfgWrapper->m_Laser2Alarm->m_IsAlarm = m_SignalState.m_Laser2Alarm;
//		m_AlarmCfgWrapper->m_Laser3Alarm->m_IsAlarm = m_SignalState.m_Laser3Alarm;
//		m_AlarmCfgWrapper->m_Laser4Alarm->m_IsAlarm = m_SignalState.m_Laser4Alarm;
//
//
//		//加热异常报警
//		if (m_SignalState.m_HeatingAlarm || m_SignalState.m_HeatingInputAlarm || m_SignalState.m_HeatingOutputAlarm) {
//			if (m_AlarmCfgWrapper->m_HeatingAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_HeatingAlarm->m_CheckAlarmSetTick) {
//				m_AlarmCfgWrapper->m_HeatingAlarm->m_IsAlarm = true;
//			}
//			else {
//				m_AlarmCfgWrapper->m_HeatingAlarm->m_AlarmContinueTick++;
//			}
//		}
//		else {
//			m_AlarmCfgWrapper->m_HeatingAlarm->m_AlarmContinueTick = 0;
//			m_AlarmCfgWrapper->m_HeatingAlarm->m_IsAlarm = false;
//		}
//
//
//		m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_IsAlarm = (m_SignalState.m_MoldMainUpLimitActive || m_SignalState.m_MoldMainDownLimitActive
//			|| m_SignalState.m_MoldSlaveUpLimitActive || m_SignalState.m_MoldSlaveDownLimitActive);
//
//		
//			//	m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm->m_IsAlarm = m_SignalState.m_PrintCabinDisableAlarm;
//		m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm->m_IsAlarm = !m_IOCfgWrapper->IsSafeDoorClose();
//		m_AlarmCfgWrapper->m_PrintCabinDoorLockOpenAlarm->m_IsAlarm = m_SignalState.m_PrintCabinLockDisableAlarm;
//		m_AlarmCfgWrapper->m_PrintSignalAlarm->m_IsAlarm = !m_IOCfgWrapper->m_PrintableSignal->IsActive();
//		m_AlarmCfgWrapper->m_InverterRunSignalAlarm->m_IsAlarm = !m_IOCfgWrapper->m_FanRunSignal->IsActive();
//		m_AlarmCfgWrapper->m_ProtectGasLackAlarm->m_IsAlarm = m_SignalState.m_ProtectGasLackAlarm;
//		m_AlarmCfgWrapper->m_ArmLimitAlarm->m_IsAlarm = (!m_SignalState.m_ArmPosInsideSoftBackLimit || !m_SignalState.m_ArmPosInsideBackLimit || !m_SignalState.m_ArmPosInsideSoftFrontLimit || !m_SignalState.m_ArmPosInsideFrontLimit);
//		EnterCriticalSection(&g_SystemInfo->m_InfoCs);
//		if (g_SystemInfo->m_ComPrintOxygen1 > m_RunCfg->m_AlarmOxygen || g_SystemInfo->m_ComPrintOxygen2 >m_RunCfg->m_AlarmOxygen) {
//			m_AlarmCfgWrapper->m_OxygenOverLimitAlarm->m_IsAlarm = true;
//		}
//		else m_AlarmCfgWrapper->m_OxygenOverLimitAlarm->m_IsAlarm = false;
//		
//		
//
//		if (m_AlarmCfgWrapper->m_FanFreqLowAlarm) {
//			if (g_SystemInfo->m_FanFrequency < m_RunCfg->m_FanFreqLowLimit) {
//				if (m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_CheckAlarmSetTick) {
//					m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_AlarmInfo = to_string(g_SystemInfo->m_FanFrequency);
//					m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_IsAlarm = true;
//				}
//				else {
//					m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_AlarmContinueTick++;
//				}
//			}
//			else {
//				m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_AlarmInfo = "";
//				m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_AlarmContinueTick = 0;
//				m_AlarmCfgWrapper->m_FanFreqLowAlarm->m_IsAlarm = false;
//			}
//		}
//
//		
//
//		m_AlarmCfgWrapper->m_MoldLoadOverLimitAlarm->m_IsAlarm = (m_SignalState.m_MoldTorqueAlarm || m_SignalState.m_MoldSlaveTorqueAlarm);
//		m_AlarmCfgWrapper->m_ArmLoadOverLimitAlarm->m_IsAlarm = m_SignalState.m_ArmTorqueAlarm;
//		
//		if (m_IOCfgWrapper->m_PurifierChillerAlarm) {
//			m_AlarmCfgWrapper->m_PurifierChillerAlarm->m_IsAlarm = m_IOCfgWrapper->m_PurifierChillerAlarm->IsActive();
//		}
//		
//		if (m_RunCfg->m_AddPowderWarnPos > (g_SystemInfo->m_PowderQtyPos*100.0f))
//		{
//			m_AlarmCfgWrapper->m_AddPowderWarn->m_IsAlarm = true;
//		}
//		else {
//			m_AlarmCfgWrapper->m_AddPowderWarn->m_IsAlarm = false;
//		}
//
//		if (m_RunCfg->m_PowderStickLowLevelAlarmPos > (g_SystemInfo->m_PowderQtyPos*100.0f))
//		{
//			m_AlarmCfgWrapper->m_PowderStickLowLevelAlarm->m_IsAlarm = true;
//		}
//		else {
//			m_AlarmCfgWrapper->m_PowderStickLowLevelAlarm->m_IsAlarm = false;
//		}
//		
//		if (m_AlarmCfgWrapper->m_HeatingTempAlarm && m_IOCfgWrapper->m_Heating)
//		{
//			if (m_IOCfgWrapper->m_Heating->IsActive()) {
//				float jtemp = g_SystemInfo->m_PlatformTempSettingValue + g_SystemInfo->m_PlatformTempSettingValue*m_ExtCfg->m_HeatingAlarmPercent / 100.0f;
//				if (g_SystemInfo->m_PlatformTemp > jtemp) {
//					if (m_AlarmCfgWrapper->m_HeatingTempAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_HeatingTempAlarm->m_CheckAlarmSetTick) {
//						m_AlarmCfgWrapper->m_HeatingTempAlarm->m_AlarmInfo = to_string(g_SystemInfo->m_PlatformTemp);
//						m_AlarmCfgWrapper->m_HeatingTempAlarm->m_IsAlarm = true;
//					}
//					else {
//						m_AlarmCfgWrapper->m_HeatingTempAlarm->m_AlarmContinueTick++;
//					}
//				}
//				else {
//					m_AlarmCfgWrapper->m_HeatingTempAlarm->m_AlarmContinueTick = 0;
//					m_AlarmCfgWrapper->m_HeatingTempAlarm->m_IsAlarm = false;
//				}
//			}
//			else {
//				m_AlarmCfgWrapper->m_HeatingTempAlarm->m_AlarmContinueTick = 0;
//				m_AlarmCfgWrapper->m_HeatingTempAlarm->m_IsAlarm = false;
//			}
//		}
//
//		if (m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm && m_ExtCfg->m_ComGetOxygen) {
//			if (!g_SystemInfo->m_IsOxygenSensorConnect) {
//				int tick = m_RunCfg->m_OxygenSensorDisconnectAlarmJudgeSecond * 1000 / m_CycleTick;
//				if (m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm->m_AlarmContinueTick > tick) {
//					m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm->m_IsAlarm = true;
//				}
//				else {
//					m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm->m_AlarmContinueTick++;
//				}
//			}
//			else {
//				m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm->m_AlarmContinueTick = 0;
//				m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm->m_IsAlarm = false;
//			}
//		}
//
//		if (m_AlarmCfgWrapper->m_HeatingDisconnectAlarm && m_IOCfgWrapper->m_Heating) {
//			int tick = m_RunCfg->m_HeatingDisconnectAlarmJudgeSecond * 1000 / m_CycleTick;
//			if (!g_SystemInfo->m_IsHeatingConnect && m_IOCfgWrapper->m_Heating->IsActive()) {
//				if (m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_AlarmContinueTick > tick) {
//					m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_IsAlarm = true;
//				}
//				else {
//					m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_AlarmContinueTick++;
//				}
//			}
//			else {
//				m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_AlarmContinueTick = 0;
//				m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_IsAlarm = false;
//			}
//		}
//		LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
//		m_AlarmCfgWrapper->m_OutdoorOxygenAlarm->m_IsAlarm = m_SignalState.m_OutsideOxygenLackAlarm;
//		m_AlarmCfgWrapper->m_SupplyPipeBlockWarn->m_IsAlarm = m_SignalState.m_SupplyPipeBlockWarn;
//
//		m_AlarmCfgWrapper->m_LinearEncoderCompensateAlarm->m_IsAlarm = m_SignalState.m_GratingRulerFail;
//		m_AlarmCfgWrapper->m_PrintMoldServoAlarm->m_IsAlarm = m_SignalState.m_PrintMoldServoAlarm;
//		m_AlarmCfgWrapper->m_ArmServoAlarm->m_IsAlarm = m_SignalState.m_ArmServoAlarm;
//		m_AlarmCfgWrapper->m_SupplyServoAlarm->m_IsAlarm = m_SignalState.m_SupplyServoAlarm;
//
//
//		if (m_SignalState.m_PrintInnerLossPressureAlarm || m_SignalState.m_PrintOxygenRiseAlarm || m_SignalState.m_PrintHandupSeparateAlarm)
//		{
//			stringstream ss;
//			if (m_SignalState.m_PrintInnerLossPressureAlarm)
//			{
//				ss << _(u8"舱内失压报警\n");
//			}
//			if (m_SignalState.m_PrintOxygenRiseAlarm) {
//				ss << _(u8"氧含量快速升高报警\n");
//			}
//			if (m_SignalState.m_PrintHandupSeparateAlarm) {
//				ss << _(u8"顶升气缸异常分离报警\n");
//			}
//			m_AlarmCfgWrapper->m_PLCInnerStopAlarm->m_AlarmInfo= ss.str();
//			m_AlarmCfgWrapper->m_PLCInnerStopAlarm->m_IsAlarm = true;
//		}
//		else {
//			m_AlarmCfgWrapper->m_PLCInnerStopAlarm->m_IsAlarm = false;
//		}
//
//		static int powderAlarmFlag = 0;
//		if (m_AlarmCfgWrapper->m_PowderEmpty)
//		{
//			if (!m_PowderEstimateCfg->m_PEVec.empty() && m_RunCfg->m_PowderAlarmPos < m_PowderEstimateCfg->m_PEVec.size()) {
//				if (m_PowderEstimateCfg->m_PEVec[m_RunCfg->m_PowderAlarmPos])
//				{
//					bool isalarm = false;
//					for (int i = 0; i <= m_RunCfg->m_PowderAlarmPos; i++) {
//						if (!m_PowderEstimateCfg->m_PEVec[i]->m_PosSensor)break;
//						if (!m_PowderEstimateCfg->m_PEVec[i]->m_PosSensor->IsActive()) {
//							isalarm = true;
//							break;
//						}
//					}
//					if (isalarm) {
//						powderAlarmFlag++;
//					}
//					else {
//						powderAlarmFlag = 0;
//					}
//					if (powderAlarmFlag > 20) {
//						m_AlarmCfgWrapper->m_PowderEmpty->m_IsAlarm = true;
//						powderAlarmFlag = 30;
//					}
//					else {
//						m_AlarmCfgWrapper->m_PowderEmpty->m_IsAlarm = false;
//					}
//				}
//			}
//		}
//
//
//		lock.unlock();
//		std::this_thread::sleep_for(chrono::milliseconds(m_CycleTick));
//	}
//}


void SignalService::GetSignalState(SignalState& ss)
{
	std::unique_lock<std::shared_mutex> lock(m_Mtx);
	ss = m_SignalState;
	//memcpy_s(&ss, sizeof(SignalState), &m_SignalState, sizeof(SignalState));
}



AlarmCfg* SignalService::JudgeStopAlarm()
{
	AlarmCfg* rel = nullptr;
	std::shared_lock<std::shared_mutex> lock(m_Mtx);
	for (auto &it : m_AlarmCfgWrapper->m_StopAlarmCfgMap) {
		AlarmCfg* alarm=it.second;
		if (alarm && alarm->m_IsEnable && alarm->m_IsAlarm) {
			rel = alarm;
			break;
		}
	}
	return rel;
}

void SignalService::JudgeStopAlarm(vector<AlarmCfg*>& vecs)
{
	vecs.clear();
	std::unique_lock<std::shared_mutex> lock(m_Mtx);
	for (auto& it : m_AlarmCfgWrapper->m_StopAlarmCfgMap) {
		AlarmCfg* alarm = it.second;
		if (alarm && alarm->m_IsShow && alarm->m_IsEnable && alarm->m_IsAlarm) {
			vecs.push_back(alarm);
		}
	}

}

void SignalService::JudgePauseAlarm(vector<AlarmCfg*>& vecs)
{
	vecs.clear();
	std::unique_lock<std::shared_mutex> lock(m_Mtx);
	for (auto& it : m_AlarmCfgWrapper->m_PauseAlarmCfgMap) {
		AlarmCfg* alarm = it.second;
		if (alarm && alarm->m_IsShow && alarm->m_IsEnable && alarm->m_IsAlarm) {
			vecs.push_back(alarm);
		}
	}

}

string SignalService::JudgeWarns(vector<AlarmCfg*>& vecs)
{
	stringstream ss;
	std::unique_lock<std::shared_mutex> lock(m_Mtx);
	for (auto& it : m_AlarmCfgWrapper->m_WarnAlarmCfgMap) {
		AlarmCfg* alarm = it.second;
		if (alarm && alarm->m_IsShow && alarm->m_IsEnable && alarm->m_IsAlarm) {
			vecs.push_back(alarm);
			ss << alarm->m_ShowContent.c_str() << " " << alarm->m_AlarmInfo.c_str() << "\n";
		}
	}

	return ss.str();
}


AlarmCfg* SignalService::JudgePauseAlarm()
{
	AlarmCfg* rel = nullptr;
	std::shared_lock<std::shared_mutex> lock(m_Mtx);
	for (auto &it : m_AlarmCfgWrapper->m_PauseAlarmCfgMap) {
		AlarmCfg* alarm = it.second;
		if (alarm && alarm->m_IsEnable && alarm->m_IsAlarm) {
			rel = alarm;
			break;
		}
	}
	return rel;
}

bool SignalService::CheckAlarmBeforeDeoxygen()
{
	vector<AlarmCfg*> checks;
	char buffer[512];
	checks.push_back(m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_SystemStopAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_PowerBreakAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_PrintCabinDoorLockOpenAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_UpDownLimitAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_PurifierDisconnectAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_BusAirSwitchAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_MoldLoadOverLimitAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_HighPressureLackAlarm);
	checks.push_back(m_AlarmCfgWrapper->m_ProtectGasLackAlarm);

	std::shared_lock<std::shared_mutex> lock(m_Mtx);
	bool noAlarm = true;
	for (size_t i = 0; i < checks.size(); i++) {
		AlarmCfg* alarm = checks[i];
		if (alarm && alarm->m_IsEnable && alarm->m_IsAlarm) {
			sprintf_s(buffer, sizeof(buffer), _(u8"%s,不能执行任务").c_str(), alarm->m_ShowContent.c_str());
			ToastBean* bean = new ToastBean(buffer, 3000, Toast::COLOR_RED);
			g_Toast->AddToast(bean);
			noAlarm = false;
			break;
		}
	}
	return noAlarm;
}

bool SignalService::CheckAlarmAfterDeoxygen()
{
	//vector<AlarmCfg*> checks;
	//char buffer[512];
	//checks.push_back(m_AlarmCfgWrapper->m_DeviceJudgeDisconnectAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PLCJudgeDisconnectAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_SystemStopAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PrintCabinDoorLockOpenAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_UpDownLimitAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PurifierDisconnectAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_BusAirSwitchAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_ExtDevicePowerAirSwitchAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_LaserPowerAirSwitchAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_MoldLoadOverLimitAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_ServoPowerAirSwitchAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_WindOverLimitAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_FanFreqLowAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_ScananerChillerAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_HeatingAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_InverterRunSignalAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_LaserChillerAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_OxygenOverLimitAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PowerBreakAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PrintSignalAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PurifierChillerAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_HighPressureLackAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_ProtectGasLackAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PurifierKeepAliveAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PurifierOxygenAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PurifierMidTempAlarm);
	//checks.push_back(m_AlarmCfgWrapper->m_PurifierInternalAlarm);
	//std::shared_lock<std::shared_mutex> lock(m_Mtx);
	bool hasAlarm = false;
	//for (size_t i = 0; i < checks.size(); i++) {
	//	AlarmCfg* alarm = checks[i];
	//	if (alarm && alarm->m_IsEnable && alarm->m_IsAlarm) {
	//		sprintf_s(buffer, sizeof(buffer), _(u8"%s,不能执行任务").c_str(), alarm->m_ShowContent.c_str());
	//		ToastBean* bean = new ToastBean(buffer, 3000, Toast::COLOR_RED);
	//		g_Toast->AddToast(bean);
	//		hasAlarm = true;
	//		break;
	//	}
	//}
	return hasAlarm;
}

string SignalService::GetWarnAlarmInfo()
{
	stringstream ss;
	std::shared_lock<std::shared_mutex> lock(m_Mtx);
	for (auto &it : m_AlarmCfgWrapper->m_WarnAlarmCfgMap) {
		AlarmCfg* alarm = it.second;
		if (alarm && alarm->m_IsEnable && alarm->m_IsAlarm) {
			ss << alarm->m_ShowContent.c_str() <<" " << alarm->m_AlarmInfo.c_str()<<"\n";
		}
	}
	return ss.str();
}



void SignalService::SetPurifierIsConnect(bool isAlarm)
{
	std::shared_lock<std::shared_mutex> lock(m_Mtx);
	m_AlarmCfgWrapper->m_PurifierDisconnectAlarm->m_IsAlarm = isAlarm;
}