#include "stdafx.h"
#include "CDataMonitor1.h"
#include "CBonder.h"
#include "Log.h"


CDataMonitor1::CDataMonitor1()
{
	m_pActivePanel = nullptr;
	m_nResponseAddr = 0;
	m_bAutoSendData = TRUE;
	m_bSampling = FALSE;
	m_hRemoveEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
	m_pszRemoveParamData = new char[4096];
}

CDataMonitor1::~CDataMonitor1()
{
	Lock();
	if (m_pActivePanel != nullptr) {
		m_pActivePanel->release();
		m_pActivePanel = nullptr;
	}

	for (auto item : m_panels) {
		item->release();
	}
	m_panels.clear();
	Unlock();

	if (m_hRemoveEvent != nullptr) {
		::CloseHandle(m_hRemoveEvent);
		m_hRemoveEvent = nullptr;
	}

	if (m_pszRemoveParamData != nullptr) {
		delete[] m_pszRemoveParamData;
		m_pszRemoveParamData = nullptr;
	}
}

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

void CDataMonitor1::OnTimer(UINT nTimerid)
{
	/*
	if (m_nIndex == 0) {
		char szData[200];
		memset(szData, 0, 200);
		strcpy_s(szData, 20, "ABC123");

		static int step = 0;
		static int iii = 0;
		iii+=5;
		if (iii == 100) {
			step = 20;
			szData[20 * 2] = 20;
			szData[20 * 2 + 1] = 0x00;

		}
		if (iii > 100 + 15 * 5 && iii < 100 + 24 * 5) {
			step = 1;
			szData[20 * 2] = 1;
			szData[20 * 2 + 1] = 0x00;
		}
		if (iii == 100 + 25 * 5) {
			step = 2;
			szData[20 * 2] = 2;
			szData[20 * 2 + 1] = 0x00;
		}
		if (iii == 100 + 35 * 5) {
			step = 30;
			szData[20 * 2] = 30;
			szData[20 * 2 + 1] = 0x00;
		}


		if (step == 1) {
			onData(1, szData, 200);
			onData(1, szData, 200);
			onData(1, szData, 200);
			onData(1, szData, 200);
			onData(1, szData, 200);
		}
		else if (step != 0) {
			onData(1, szData, 200);
		}
	}
	else {

	}
	*/
}

void CDataMonitor1::onData(int unitId, const void* pData, int size)
{
	if (m_nIndex + 1 != unitId) return;

	const char* pszData = (const char*)pData;
	BEQ::IUnit* pUnit = m_pBonder->getUnit(m_nIndex);
	ASSERT(pUnit);


	// Ïȼì²é²ÉÑù±êÖ¾
	// sapmleFlag: 1²ÉÑù£¬2½áÊø²ÉÑù£¬20ÈëÕ¾£¬30³öÕ¾
	int i, v;
	i = 20 * 2;
	int sampleFlag = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
	if (sampleFlag == STEP_RECEIVED) {
		WriteResultFlag(unitId, STEP_RECEIVED);

		CString strId;
		for (int i = 0; i < 10 * 20; i++) {
			strId.Insert(strId.GetLength(), pszData[i]);
		}

		// µ±Ç°Ãæ°å
		Lock();
		if (m_pActivePanel == nullptr) {
			m_pActivePanel = new CPanel((LPTSTR)(LPCTSTR)strId, m_nIndex);
			m_pActivePanel->setStep(STEP_RECEIVED);
			m_pActivePanel->addRef();
			SendBroadcast(&CIntent(BC_CODE_DATA1_MATERIAL_RECEIVED, "", nullptr));
			LOGI("<CDataMonitor1-%d>²úÆ·×¼±¸ÈëÕ¾£¬id=%s.", m_nIndex, (LPTSTR)(LPCTSTR)strId);
			pUnit->stepMaterialReceived((LPTSTR)(LPCTSTR)strId);
		}
		ASSERT(m_pActivePanel);
		LOGI("<CDataMonitor1-%d>²úÆ·ÒÑÈëÕ¾£¬id=%s.", m_nIndex, (LPTSTR)(LPCTSTR)strId);
		Unlock();
	}
	else if (sampleFlag == STEP_BEGIN_SAMPLING) {
		m_bSampling = TRUE;
		WriteResultFlag(unitId, STEP_BEGIN_SAMPLING);

		// µ±Ç°Ãæ°å
		if (m_pActivePanel != nullptr) {
			if (m_pActivePanel->getStep() == STEP_RECEIVED) {
				m_pActivePanel->setStep(STEP_BEGIN_SAMPLING);
				LOGI("<CDataMonitor1-%d>²ÉÑù¿ªÊ¼.", m_nIndex);
				pUnit->stepProcessingStarted(m_pActivePanel->getQRCode().c_str());
				SendBroadcast(&CIntent(BC_CODE_DATA1_BEGIN_SAMPLING, "", nullptr));
			}
		}
	}
	else if (sampleFlag == STEP_READY) {
		// µ±Ç°Ãæ°å
		if (m_bSampling && m_pActivePanel != nullptr) {

			// ÉÏÇ»ÌåζÈ
			UNITDATA1 ud1;
			ud1.time = m_pActivePanel->GetCurrentSampleTime();

			i = 30 * 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[0] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[1] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[2] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[3] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[4] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[5] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[6] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[7] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[8] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[9] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[10] = v * 0.1f;
			i += 2;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			ud1.temp[11] = v * 0.1f;
			LOGD("<CDataMonitor1-%d>ζȣº%f %f %f %f %f %f %f %f %f %f %f %f", m_nIndex,
				ud1.temp[0], ud1.temp[1], ud1.temp[2], ud1.temp[3], ud1.temp[4],
				ud1.temp[5], ud1.temp[6], ud1.temp[7], ud1.temp[8], ud1.temp[9], ud1.temp[10], ud1.temp[11]);


			// Õæ¿Õ
			i += 18;
			ud1.vacuum = toFloat(&pszData[i]);
			LOGD("<CDataMonitor1-%d>vacuum: %f", m_nIndex,
				ud1.vacuum);


			// ѹÁ¦
			i += 10;
			ud1.pressure[0] = short((pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8);
			i += 2;
			ud1.pressure[1] = short((pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8);
			i += 2;
			ud1.pressure[2] = short((pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8);
			i += 2;
			ud1.pressure[3] = short((pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8);
			i += 2;
			ud1.pressure[4] = short((pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8);
			LOGD("<CDataMonitor1-%d>pressure: %.03f %.03f %.03f %.03f %.03f", m_nIndex,
				ud1.pressure[0], ud1.pressure[1], ud1.pressure[2], ud1.pressure[3], ud1.pressure[4]);

			Lock();
			size_t size = m_pActivePanel->addData(ud1);
			Unlock();
			int nSvTime = 15 * 60 * 5;
			int nTvTime = (int)size;
			if (nTvTime % (60 * 5) == 0 && nTvTime < nSvTime) {
				pUnit->stepProcessing(m_pActivePanel->getQRCode().c_str(), 15, nTvTime / (60 * 5));
			}

			// unit data
			CString strTmp, strAir, strPre;
			for (int i = 0; i < 12; i++) {
				strTmp.AppendFormat("%.2f,", ud1.temp[i]);
			}
			strTmp.Delete(strTmp.GetLength() - 1);
			strAir.Format("%.2f", ud1.vacuum);
			for (int i = 0; i < 5; i++) {
				strPre.AppendFormat("%.2f,", ud1.pressure[i]);
			}
			strPre.Delete(strPre.GetLength() - 1);

			pUnit->setDataTimeAndResetData(ud1.time);
			pUnit->addData("TMP", (LPTSTR)(LPCTSTR)strTmp, false);
			pUnit->addData("AIR", (LPTSTR)(LPCTSTR)strAir, false);
			pUnit->addData("PRE", (LPTSTR)(LPCTSTR)strPre, m_bAutoSendData != FALSE);

			SendBroadcast(&CIntent(BC_CODE_DATA1_UPDATE, "", nullptr));
		}
	}
	else if (sampleFlag == STEP_END_SAMPLING) {
		m_bSampling = FALSE;
		WriteResultFlag(unitId, STEP_END_SAMPLING);

		// ²ÉÑù½áÊø
		if (m_pActivePanel != nullptr) {
			m_pActivePanel->setStep(STEP_END_SAMPLING);
			SendBroadcast(&CIntent(BC_CODE_DATA1_END_SAMPLING, "", nullptr));

			pUnit->stepProcessingCompleted(m_pActivePanel->getQRCode().c_str());
			LOGI("<CDataMonitor1-%d>²ÉÑù½áÊø.", m_nIndex);
		}
	}
	else if (sampleFlag == STEP_REMOVED) {
		WriteResultFlag(unitId, STEP_REMOVED);
		if (m_pActivePanel != nullptr) {
			// 20241111£¬¿Í»§ÒªÇóÐÂÔö³öվʱ¶ÁÈ¡Ò»´ó¿é²ÎÊý
			BOOL bReadOk;
			bReadOk = m_pBonder->readDataBlocking(m_hRemoveEvent, MC::SOFT_COMPONENT::D,
				5500, 800, &m_pszRemoveParamData[0]);
			if (bReadOk) {
				bReadOk = m_pBonder->readDataBlocking(m_hRemoveEvent, MC::SOFT_COMPONENT::D,
					5900, 800, &m_pszRemoveParamData[800]);
			}
			if (bReadOk) {
				bReadOk = m_pBonder->readDataBlocking(m_hRemoveEvent, MC::SOFT_COMPONENT::D,
					6300, 800, &m_pszRemoveParamData[1600]);
			}
			if (bReadOk) {
				m_pActivePanel->SetParamsRawData(m_pszRemoveParamData);
			}

			// ¼Ç¼µ±Ç°²ÎÊýºÍÅä·½
			i = 70 * 2;
			double air = toFloat(&pszData[i]);
			m_pActivePanel->setAir1(air);
			i += 4;
			air = toFloat(&pszData[i]);
			m_pActivePanel->setAir2(air);
			i += 4;
			air = toFloat(&pszData[i]);
			m_pActivePanel->setAir3(air);
			i += 4;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24;
			m_pActivePanel->setPre1(v);
			i += 4;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			m_pActivePanel->setTmp1(v * 0.1);
			i += 4;
			v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8;
			m_pActivePanel->setTmp2(v * 0.1);
			m_pActivePanel->setRecipeName(m_pBonder->getCurRecipeName().c_str());

			LOGI("<CDataMonitor1-%d>Recipe:%s, ¸É±ÃÎüÕæ¿ÕÖµ:%f,·Ö×Ó±ÃÎüÕæ¿ÕÖµ:%f",
				m_nIndex,
				m_pActivePanel->getRecipeName().c_str(),
				m_pActivePanel->getAir1(),
				m_pActivePanel->getAir2());
			LOGI("<CDataMonitor1-%d>ÆøÄÒѹÁ¦Öµ:%f,ÌùºÏ×ÜѹÁ¦:%d",
				m_nIndex,
				m_pActivePanel->getAir3(),
				m_pActivePanel->getPre1());
			LOGI("<CDataMonitor1-%d>ÉÏÇ»ÌåζÈ:%f,ÏÂÇ»ÌåζÈ:%f",
				m_nIndex,
				m_pActivePanel->getTmp1(),
				m_pActivePanel->getTmp2());

			m_pActivePanel->setStep(STEP_REMOVED);
			SendBroadcast(&CIntent(BC_CODE_DATA1_MATERIAL_REMOVED, "", m_pActivePanel));
			AddPanel(m_pActivePanel);

			pUnit->stepMaterialRemoved(m_pActivePanel->getQRCode().c_str());
			Sleep(50);
			pUnit->stepIdle();

			m_pActivePanel->release();
			m_pActivePanel = nullptr;
			LOGI("<CDataMonitor1-%d>³öÕ¾.", m_nIndex);
		}
	}
}

CPanel* CDataMonitor1::getActivePanel()
{
	return m_pActivePanel;
}

void CDataMonitor1::setResponseAddr(int addr)
{
	m_nResponseAddr = addr;
}

void CDataMonitor1::enableAutoSendData(BOOL bEnable)
{
	m_bAutoSendData = bEnable;
}

const std::list<CPanel*>& CDataMonitor1::getPanels()
{
	return m_panels;
}

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

void CDataMonitor1::term()
{
	CComponent::term();
}

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

}

void CDataMonitor1::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		Lock();
		int count = (int)m_panels.size() + (m_pActivePanel != nullptr ? 1 : 0);
		ar << count;
		for (auto item : m_panels) {
			item->Serialize(ar);
		}
		if (m_pActivePanel != nullptr) {
			m_pActivePanel->Serialize(ar);
		}
		Unlock();
	}
	else
	{
		Lock();
		int count;
		ar >> count;
		for (int i = 0; i < count; i++) {
			CPanel* pPanel = new CPanel();
			pPanel->addRef();
			pPanel->Serialize(ar);
			AddPanel(pPanel);
			pPanel->release();
			
		}
		Unlock();
	}
}

void CDataMonitor1::AddPanel(CPanel* pPanel)
{
	pPanel->addRef();
	m_panels.push_back(pPanel);
	if (m_panels.size() > 4 * 24) {
		CPanel* pTemp = m_panels.front();
		pTemp->release();
		m_panels.pop_front();
	}
}

void CDataMonitor1::WriteResultFlag(int unitId, int flag)
{
	WriteInt(unitId, m_nResponseAddr, flag);
}