#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();
}

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_PLCKeepliveAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_PLCKeepliveAlarm->m_CheckAlarmSetTick)
			{
				m_AlarmCfgWrapper->m_PLCKeepliveAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_PLCKeepliveAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_PLCKeepliveAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_PLCKeepliveAlarm->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_UpLaserAirSwitchAlarm) {
			if (m_AlarmCfgWrapper->m_UpLaserAirBreakAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_UpLaserAirBreakAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_UpLaserAirBreakAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_UpLaserAirBreakAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_UpLaserAirBreakAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_UpLaserAirBreakAlarm->m_IsAlarm = false;
		}

		//上层伺服空开异常报警
		if (m_SignalState.m_UpServoAirSwitchAlarm) {
			if (m_AlarmCfgWrapper->m_UpServoAirBreakAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_UpServoAirBreakAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_UpServoAirBreakAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_UpServoAirBreakAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_UpServoAirBreakAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_UpServoAirBreakAlarm->m_IsAlarm = false;
		}

		//振镜电源异常报警
		if (m_SignalState.m_ScannerPowerExceptionAlarm) {
			if (m_AlarmCfgWrapper->m_ScannerPowerExceptionAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_ScannerPowerExceptionAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_ScannerPowerExceptionAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_ScannerPowerExceptionAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_ScannerPowerExceptionAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_ScannerPowerExceptionAlarm->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;
		m_AlarmCfgWrapper->m_Laser5Alarm->m_IsAlarm = m_SignalState.m_Laser5Alarm;
		m_AlarmCfgWrapper->m_Laser6Alarm->m_IsAlarm = m_SignalState.m_Laser6Alarm;
		m_AlarmCfgWrapper->m_Laser7Alarm->m_IsAlarm = m_SignalState.m_Laser7Alarm;
		m_AlarmCfgWrapper->m_Laser8Alarm->m_IsAlarm = m_SignalState.m_Laser8Alarm;

		//加热异常报警
		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;
		}

		//升降限位报警
		if ((m_SignalState.m_MoldMainUpLimitActive || m_SignalState.m_MoldMainDownLimitActive
			|| m_SignalState.m_MoldSlaveUpLimitActive || m_SignalState.m_MoldSlaveDownLimitActive)) {
			if (m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_UpDownLimitAlarm->m_IsAlarm = false;
		}

		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;
		//	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;

		//UPS报警
		if (m_SignalState.m_UpsAlarm) {
			if (m_AlarmCfgWrapper->m_UPSAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_UPSAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_UPSAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_UPSAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_UPSAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_UPSAlarm->m_IsAlarm = false;
		}

		//轨道打印位感应失效报警
		if (m_SignalState.m_PrintTrackDisableWarn) {
			if (m_AlarmCfgWrapper->m_PrintTrackDisableAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_PrintTrackDisableAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_PrintTrackDisableAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_PrintTrackDisableAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_PrintTrackDisableAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_PrintTrackDisableAlarm->m_IsAlarm = false;
		}

		//清粉升降急停异常
		if (m_SignalState.m_CleanLiftStopAlarm) {
			if (m_AlarmCfgWrapper->m_CleanLiftStopAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_CleanLiftStopAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_CleanLiftStopAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_CleanLiftStopAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_CleanLiftStopAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_CleanLiftStopAlarm->m_IsAlarm = false;
		}

		//主电源缺相检测异常
		if (m_SignalState.m_MainPowerLossCheckAlarm) {
			if (m_AlarmCfgWrapper->m_MainPowerLossCheckAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_MainPowerLossCheckAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_MainPowerLossCheckAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_MainPowerLossCheckAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_MainPowerLossCheckAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_MainPowerLossCheckAlarm->m_IsAlarm = false;
		}

		//铺粉限位报警
		if (m_SignalState.m_ArmFrontLimit || m_SignalState.m_ArmBackLimit) {
			if (m_AlarmCfgWrapper->m_ArmLimitAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_ArmLimitAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_ArmLimitAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_ArmLimitAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_ArmLimitAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_ArmLimitAlarm->m_IsAlarm = false;
		}

		//总冷水机报警
		if (m_SignalState.m_TotalWaterCoolerAlarm) {
			if (m_AlarmCfgWrapper->m_GeneralChillerAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_GeneralChillerAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_GeneralChillerAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_GeneralChillerAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_GeneralChillerAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_GeneralChillerAlarm->m_IsAlarm = false;
		}

		//打印主轴软限位报警
		if (m_SignalState.m_PrintMainOverSoftUpLimit || m_SignalState.m_PrintMainOverSoftDownLimit) {
			if (m_AlarmCfgWrapper->m_MainMoldSoftLimitAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_MainMoldSoftLimitAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_MainMoldSoftLimitAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_MainMoldSoftLimitAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_MainMoldSoftLimitAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_MainMoldSoftLimitAlarm->m_IsAlarm = false;
		}

		//铺粉软限位报警
		if (m_SignalState.m_ArmOverSoftFrontLimit || m_SignalState.m_ArmOverSoftBackLimit) {
			if (m_AlarmCfgWrapper->m_ArmSoftLimitAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_ArmSoftLimitAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_ArmSoftLimitAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_ArmSoftLimitAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_ArmSoftLimitAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_ArmSoftLimitAlarm->m_IsAlarm = false;
		}

		//上层维修门打开报警
		if (m_SignalState.m_UpServiceDoorOpenWarn) {
			if (m_AlarmCfgWrapper->m_UpServiceDoorOpenAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_UpServiceDoorOpenAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_UpServiceDoorOpenAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_UpServiceDoorOpenAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_UpServiceDoorOpenAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_UpServiceDoorOpenAlarm->m_IsAlarm = false;
		}

		//下层维修门打开报警
		if (m_SignalState.m_DownServiceDoorOpenWarn) {
			if (m_AlarmCfgWrapper->m_DownServiceDoorOpenAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_DownServiceDoorOpenAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_DownServiceDoorOpenAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_DownServiceDoorOpenAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_DownServiceDoorOpenAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_DownServiceDoorOpenAlarm->m_IsAlarm = false;
		}

		//铺粉归原点异常报警
		if (m_SignalState.m_CoverHomeException) {
			if (m_AlarmCfgWrapper->m_ArmCatpureHomeAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_ArmCatpureHomeAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_ArmCatpureHomeAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_ArmCatpureHomeAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_ArmCatpureHomeAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_ArmCatpureHomeAlarm->m_IsAlarm = false;
		}

		//密封圈压力异常报警
		if (m_SignalState.m_SealPressureExceptionWhenPrint) {
			if (m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->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;

		m_AlarmCfgWrapper->m_InverterRunSignalAlarm->m_IsAlarm = !m_IOCfgWrapper->m_FanRunSignal->IsActive();




		if (m_IOCfgWrapper->m_PrintableSignal) {
			if (!m_IOCfgWrapper->m_PrintableSignal->IsActive()) {
				if (m_AlarmCfgWrapper->m_PrintSignalAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_PrintSignalAlarm->m_CheckAlarmSetTick) {
					m_AlarmCfgWrapper->m_PrintSignalAlarm->m_IsAlarm = true;
				}
				else {
					m_AlarmCfgWrapper->m_PrintSignalAlarm->m_AlarmContinueTick++;
				}
			}
			else {
				m_AlarmCfgWrapper->m_PrintSignalAlarm->m_AlarmContinueTick = 0;
				m_AlarmCfgWrapper->m_PrintSignalAlarm->m_IsAlarm = false;
			}
		}


		if (m_SignalState.m_SealPressureExceptionWhenPrint) {
			if (m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_CheckAlarmSetTick) {
				m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_IsAlarm = true;
			}
			else {
				m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_AlarmContinueTick++;
			}
		}
		else {
			m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_AlarmContinueTick = 0;
			m_AlarmCfgWrapper->m_SealPressureExceptionAlarm->m_IsAlarm = false;
		}


		if (m_IOCfgWrapper->m_PurifierChillerAlarm) {
			m_AlarmCfgWrapper->m_PurifierChillerAlarm->m_IsAlarm = m_IOCfgWrapper->m_PurifierChillerAlarm->IsActive();
		}

		m_AlarmCfgWrapper->m_ProtectGasLackAlarm->m_IsAlarm = m_SignalState.m_ProtectGasLackAlarm;

		EnterCriticalSection(&g_SystemInfo->m_InfoCs);
		if (g_SystemInfo->m_ComPrintOxygen1 > m_RunCfg->m_AlarmOxygen->GetValue() || g_SystemInfo->m_ComPrintOxygen2 > m_RunCfg->m_AlarmOxygen->GetValue()) {
			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->GetValue()) {
				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;
			}
		}




		if (m_RunCfg->m_AddPowderWarnPos->GetValue() > (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->GetValue() > (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) {
				if (m_AlarmCfgWrapper->m_OxygenSensorDisconnectAlarm->m_AlarmContinueTick > 300) {
					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) {
			if (!g_SystemInfo->m_IsHeatingConnect && m_IOCfgWrapper->m_Heating->IsActive()) {
				if (m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_AlarmContinueTick > m_AlarmCfgWrapper->m_HeatingDisconnectAlarm->m_CheckAlarmSetTick) {
					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;



		static int powderAlarmFlag = 0;
		if (m_AlarmCfgWrapper->m_PowderEmpty)
		{
			if (!m_PowderEstimateCfg->m_PEVec.empty() && m_RunCfg->m_PowderAlarmPos->GetValue() < m_PowderEstimateCfg->m_PEVec.size()) {
				if (m_PowderEstimateCfg->m_PEVec[m_RunCfg->m_PowderAlarmPos->GetValue()])
				{
					bool isalarm = false;
					for (int i = 0; i <= m_RunCfg->m_PowderAlarmPos->GetValue(); 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(100));
	}
}


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_IsShow && 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_Content.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_IsShow && 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);
	checks.push_back(m_AlarmCfgWrapper->m_PipeWaterTempAlarm);
	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_IsShow && alarm->m_IsEnable && alarm->m_IsAlarm) {
			sprintf_s(buffer, sizeof(buffer), g_LngManager->Toast_CheckAlarmInfo->ShowText(), alarm->m_Content.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_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);
	checks.push_back(m_AlarmCfgWrapper->m_PipeWaterTempAlarm);
	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_IsShow && alarm->m_IsEnable && alarm->m_IsAlarm) {
			sprintf_s(buffer, sizeof(buffer), g_LngManager->Toast_CheckAlarmInfo->ShowText(), alarm->m_Content.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_IsShow && alarm->m_IsEnable && alarm->m_IsAlarm) {
			ss << alarm->m_Content.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;
}