#include "stdafx.h"
#include "AlarmMonitor.h"
#include "Common.h"
#include "CBonder.h"
#include "Log.h"
#include "ToolUnits.h"

#define ALARM_MAX		200

CAlarmMonitor::CAlarmMonitor()
{
	m_pRawData = new char[512];
	memset(m_pRawData, 0, 512);
}


CAlarmMonitor::~CAlarmMonitor()
{
	if (m_pRawData != nullptr) {
		delete[] m_pRawData;
		m_pRawData = nullptr;
	}

	for (auto item : m_mapAlarmTemplate) {
		delete item.second;
	}
	m_mapAlarmTemplate.clear();

	for (auto item : m_mapAlarming) {
		item.second->release();
	}
	m_mapAlarming.clear();
}

std::string& CAlarmMonitor::getClassName()
{
	static std::string strClassName = "CAlarmMonitor";
	return strClassName;
}

void CAlarmMonitor::onRecvBroadcast(void* pSender, CIntent* pIntent)
{

}

void CAlarmMonitor::onData(int id, const void* pData, int size)
{
	const char* pszData = (const char*)pData;
	if (MONITOR_ID_ALARM != id) {
		return;
	}

	// ±È½ÏÓÐûÓб仯
	if (compareData(m_pRawData, (const char*)pData, size)) {
		return;
	}
	memcpy(m_pRawData, (const char*)pData, size);


	// ÕÒµ½OnµÄ±¨¾¯²¢»º´æ
	std::vector<int> alarmIds;
	for (auto item : m_mapAlarmTemplate) {
		if (isAlarmOn(item.first)) {
			alarmIds.push_back(item.first);
		}
	}


	// ·¢Éú¾¯¸æ£º
	// ±È½ÏмӵÄONµÄ¾¯¸æ
	// ¼´m_mapAlarmingÎÞ£¬alarmIdsÓÐ
	for (auto item : alarmIds) {
		if (m_mapAlarming.find(item) == m_mapAlarming.end()) {
			auto iter = m_mapAlarmTemplate.find(item);
			if (iter != m_mapAlarmTemplate.end()) {
				CAlarm* pAlarm = new CAlarm(iter->second);
				pAlarm->alarmOn();
				pAlarm->addRef();
				m_mapAlarming[item] = pAlarm;
				LOGE("·¢ÉúÁ˾¯¸æ:%s", pAlarm->toString().c_str());

				// ¾¯¸æÐÅÏ¢·¢³ö£¬ÒÔʹ½çÃæÏÔʾºÍÀúÊ·¼Ç¼±£´æ
				SendBroadcast(&CIntent(BC_CODE_ALARM_ON, "", pAlarm));
			}
		}
	}

	// Ï÷³ý¾¯¸æ£º
	// ±È½ÏµÃµ½Ô­À´ON(m_mapAlarmingÓÐ), ÏÖÔÚOFFµÄ¾¯¸æ(alarmIdsÎÞ)
	for (auto iter = m_mapAlarming.begin(); iter != m_mapAlarming.end();/* iter++*/) {
		if (!findAlarm(alarmIds, iter->first)) {
			// Ïû³ý¾¯¸æ, ͬʱ½«ÐÅÏ¢·¢³ö£¬ÒÔʹ½çÃæÏÔʾºÍÀúÊ·¼Ç¼±£´æ
			CAlarm* pAlarm = iter->second;
			pAlarm->alarmOff();
			addAlarmToHistoryRecord(pAlarm);
			m_mapAlarming.erase(iter++);

			LOGE("Ïû³ýÁ˾¯¸æ:%s", pAlarm->toString().c_str());
			SendBroadcast(&CIntent(BC_CODE_ALARM_OFF, "", pAlarm));
			pAlarm->release();
		}
		else {
			iter++;
		}
	}
}

int CAlarmMonitor::readAlarmListFromFile(const char* pszFilepath)
{
	CStdioFile file;
	if (!file.Open(pszFilepath, CFile::modeRead)) {
		return -1;
	}

	CString strLine, strNumber, strLevel, strDescription;
	int number, level;
	while (file.ReadString(strLine)) {
		if (!AfxExtractSubString(strNumber, (LPCTSTR)strLine, 0, ','))
			continue;
		if (!AfxExtractSubString(strLevel, (LPCTSTR)strLine, 1, ','))
			continue;
		if (!AfxExtractSubString(strDescription, (LPCTSTR)strLine, 2, ','))
			continue;

		try {
			number = std::stoi((LPTSTR)(LPCTSTR)strNumber);
			level = std::stoi((LPTSTR)(LPCTSTR)strLevel);
		}
		catch (...) {
			continue;
		}

		addAlarmTemplate(number, level, (LPTSTR)(LPCTSTR)strDescription);
	}

	file.Close();
	return (int)m_mapAlarmTemplate.size();
}

void CAlarmMonitor::init()
{
	CComponent::init();
}

void CAlarmMonitor::term()
{

}

void CAlarmMonitor::OnTimer(UINT nTimerid)
{

}

const char* CAlarmMonitor::getAlarmText(int nID)
{
	auto iter = m_mapAlarmTemplate.find(nID);
	if (iter == m_mapAlarmTemplate.end()) return "";
	return iter->second->getText().c_str();
}

void CAlarmMonitor::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		Lock();
		int count = (int)m_mapAlarming.size();
		ar << count;
		for (auto item : m_mapAlarming) {
			item.second->Serialize(ar);
		}
		Unlock();
	}
	else
	{
		Lock();
		int count;
		ar >> count;
		for (int i = 0; i < count; i++) {
			CAlarm* pAlarm = new CAlarm();
			pAlarm->addRef();
			pAlarm->Serialize(ar);
			addAlarming(pAlarm);
			pAlarm->release();
		}
		Unlock();
	}
}

std::map<int, CAlarm*>& CAlarmMonitor::getAlarmingMap()
{
	return m_mapAlarming;
}

BOOL CAlarmMonitor::isAlarming()
{
	Lock();
	BOOL bAlarming = !m_mapAlarming.empty();
	Unlock();
	return bAlarming;
}

CAlarm* CAlarmMonitor::getActiveAlarm()
{
	Lock();
	if (m_mapAlarming.empty()) {
		Unlock();
		return nullptr;
	}
	auto iter = m_mapAlarming.begin();
	Unlock();

	return iter->second;
}

BOOL CAlarmMonitor::compareData(const char* pScrData, const char* pTarData, int len)
{
	for (int i = 0; i < len; i++) {
		if (pScrData[i] != pTarData[i]) {
			return FALSE;
		}
	}

	return TRUE;
}

int CAlarmMonitor::addAlarmTemplate(int id, int level, const char* pszDescription)
{
	auto iter = m_mapAlarmTemplate.find(id);
	if (iter != m_mapAlarmTemplate.end()) return -1;

	CAlarm* pAlarm = new CAlarm(id, level, pszDescription);
	m_mapAlarmTemplate[id] = pAlarm;
	return 0;
}

BOOL CAlarmMonitor::isAlarmOn(int id)
{
	int byteIndex, bitIndex;
	byteIndex = (id - 1) / 8;
	bitIndex = (id - 1) % 8;

	return CToolUnits::getBit(m_pRawData[byteIndex], bitIndex);
}

BOOL CAlarmMonitor::findAlarm(std::vector<int>& ids, int id)
{
	for (auto item : ids) {
		if (item == id) return TRUE;
	}

	return FALSE;
}

void CAlarmMonitor::addAlarmToHistoryRecord(CAlarm* pAlarm)
{
	// ¼ÓÈëÊý¾Ý¿â
	AlarmManager::getInstance().addAlarm(
		std::to_string(pAlarm->getId()).c_str(),
		getAlarmText(pAlarm->getId()),
		CToolUnits::timeToString2(pAlarm->getOnTime()).c_str(),
		CToolUnits::timeToString2(pAlarm->getOffTime()).c_str());
}

BOOL CAlarmMonitor::addAlarming(CAlarm* pAlarm)
{
	auto iter = m_mapAlarming.find(pAlarm->getId());
	if (iter != m_mapAlarming.end()) return FALSE;

	pAlarm->addRef();
	m_mapAlarming[pAlarm->getId()] = pAlarm;

	return TRUE;
}