#include "pch.h"
#include "CHsmsActive.h"
#include "Log.h"


static unsigned short DATAID = 1;

CHsmsActive::CHsmsActive()
{
	m_listener = {};
	m_pActive = nullptr;
	m_nSessionId = 0;
	m_nSystemByte = 0;
}

CHsmsActive::~CHsmsActive()
{

}

void CHsmsActive::setListener(ACTIVEListener listener)
{
	m_listener = listener;
}

int CHsmsActive::init(const char* pszIp, int port)
{
	m_strIp = pszIp;
	m_nPort = port;

	auto onStatusChanged = [&](void* pFrom, ACTIVESTATE state) -> void {
		if (m_listener.onStateChanged != nullptr) {
			m_listener.onStateChanged(this, state);
		}

		if (ACTIVESTATE::NOT_SELECTED == state) {
			LOGI("Active state changed(NOT_SELECTED).");
			hsmsSelectRequest();
		}
		else if (ACTIVESTATE::SELECTED == state) {
			LOGI("Active state changed(SELECTED).");
			hsmsEstablishCommunications();
		}
		else if (ACTIVESTATE::NOT_CONNECTED == state) {
			LOGI("Active state changed(NOT_CONNECTED).");
			m_pActive->disconnect();
		}
	};
	auto onRecvSysMessage = [&](void* pFrom, IMessage* pMessage) -> void {
		LOGI("onRecvSysMessage(sessionId:%d, sType:%d).", 
			pMessage->getHeader()->sessionId, pMessage->getHeader()->sType);
		TRACE("sessionId:%d, sType:%d\n", pMessage->getHeader()->sessionId, pMessage->getHeader()->sType);
	};

	auto onError = [&](void* pFrom, int error) -> void {
		TRACE("onError:%d\n", error);
	};

	auto onRecvRawData = [&](void* pFrom, const char* pszData, int size) {
		TRACE("onRec ,vRawData:<0x%x, %d>\n", pszData, size);
	};

	auto onRecvDataMessage = [&](void* pFrom, IMessage* pMessage) -> void {
		HEADER* pHeader = pMessage->getHeader();
		int nStream = (pHeader->stream & 0x7F);

		TRACE("收到消息 S%dF%d================\n", pHeader->stream & 0x7F, pHeader->function);
		TRACE("Body:%s\n", pMessage->toString());
		LOGI("onRecvDataMessage(%s).", pMessage->toString());

		if (nStream == 5 && pHeader->function == 1) {
			// S5F1
			replyAck(5, 2, pMessage->getHeader()->systemBytes, 0, _T("ACK0"));
		}
		else if (nStream == 6 && pHeader->function == 11) {
			// S5F1
			replyAck(6, 12, pMessage->getHeader()->systemBytes, 0, _T("ACK0"));
		}
	};

	ActiveListener listener;
	listener.funStateChanged = onStatusChanged;
	listener.funRecvRawData = onRecvRawData;
	listener.funRecvDataMessage = onRecvDataMessage;
	listener.funRecvSysMessage = onRecvSysMessage;
	listener.funError = onError;
	int nRet = HSMS_CreateActive(m_pActive, _T(""), m_strIp.c_str(), m_nPort);
	if (nRet == 0 && m_pActive != nullptr) {
		m_pActive->setListener(listener);
		m_pActive->connect();
	}

	return 0;
}

int CHsmsActive::term()
{
	if (m_pActive != nullptr) {
		::HSMS_DestroyActive(m_pActive);
		m_pActive = nullptr;
	}

	return 0;
}

int CHsmsActive::hsmsSelectRequest()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_CreateMessageWithSType(pMessage, MSG_SELECT_REQ, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsDeselectRequest()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_CreateMessageWithSType(pMessage, MSG_DESELECT_REQ, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsEstablishCommunications()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 | REPLY, 13, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsAreYouThere()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 | REPLY, 1, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsRequestOnline()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 | REPLY, 17, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);
	return 0;
}

int CHsmsActive::hsmsRequestOffline()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 | REPLY, 15, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);
	return 0;
}

int CHsmsActive::hsmsGoLocal()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 41, ++m_nSystemByte);
	ISECS2Item* pBody = pMessage->getBody();
	pBody->addItem("GoLocal", "RCMD");
	pBody->addItem(); // L: empty params
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);
	return 0;
}

int CHsmsActive::hsmsGoRemote()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 41, ++m_nSystemByte);
	ISECS2Item* pBody = pMessage->getBody();
	pBody->addItem("GoRemote", "RCMD");
	pBody->addItem(); // L: empty params
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);
	return 0;
}

int CHsmsActive::hsmsDatetimeSync()
{
	CTime time = CTime::GetCurrentTime();
	char szTime[256];
	sprintf_s(szTime, 256, _T("%4d%02d%02d%02d%02d%02d00"), time.GetYear(),
		time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());

	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 31, ++m_nSystemByte);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->setString((const char*)szTime, _T("Date time"));
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsTerminalDisplay(BYTE tid, const char* pszText)
{
	char szTid[1];
	szTid[0] = tid;

	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 10 | REPLY, 3, ++m_nSystemByte);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->addBinaryItem(szTid, 1, _T("TID"));
	pItem->addItem(pszText, _T("TEXT"));
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsEDEventReport(bool bEnable, std::vector<int>& ids)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 37, ++m_nSystemByte);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->addBoolItem(bEnable, "CEED");
	ISECS2Item* pItem2 = pItem->addItem();
	for (auto item : ids) {
		pItem2->addU4Item(item, "CEID");
	}
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsEDAlarmReport(bool bEnable, unsigned int id)
{
	char szEnable[2] = {128, 0};

	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 5 | REPLY, 3, ++m_nSystemByte);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->addBinaryItem(&szEnable[bEnable ? 0 : 1], 1, "ALED");
	pItem->addU4Item(id, "ALID");
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsDefineReports(std::map<unsigned int, std::vector<unsigned int>>& mapReport)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 33, ++m_nSystemByte);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->addU4Item(1, "DATAID");
	ISECS2Item* pItemReportList = pItem->addItem();
	for (auto item : mapReport) {
		ISECS2Item* pItemReport = pItemReportList->addItem();
		pItemReport->addU4Item(item.first, "RPTID");
		ISECS2Item* pItemVidList = pItemReport->addItem();
		for (auto vid : item.second) {
			pItemVidList->addU4Item(vid, "VID");
		}
	}
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsLinkEventReport(std::map<unsigned int, std::vector<unsigned int>>& mapEvent)
{
	if (mapEvent.empty()) return 0;

	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 35, ++m_nSystemByte);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->addU4Item(1, "DATAID");
	ISECS2Item* pItemEventList = pItem->addItem();
	for (auto item : mapEvent) {
		ISECS2Item* pItemEvent = pItemEventList->addItem();
		pItemEvent->addU4Item(item.first, "CEID");
		ISECS2Item* pItemRptidList = pItemEvent->addItem();
		for (auto vid : item.second) {
			pItemRptidList->addU4Item(vid, "RPTID");
		}
	}
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsConfigureSpooling(std::map<unsigned int, std::set<unsigned int>>& spoolingConfig)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 2 | REPLY, 43, ++m_nSystemByte);
	if (spoolingConfig.size() > 0) {
		for (auto s : spoolingConfig) {
			ISECS2Item* pItemStreamList = pMessage->getBody()->addItem();
			pItemStreamList->addU1Item(s.first, "STRID");
			ISECS2Item* pItemFcnList = pItemStreamList->addItem();
			for (auto f : s.second) {
				pItemFcnList->addU1Item(f, "FCNID");
			}
		}
	}

	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsTransmitSpooledData()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 6 | REPLY, 23, ++m_nSystemByte);
	pMessage->getBody()->setU1(0, "RSDC");
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsPurgeSpooledData()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 6 | REPLY, 23, ++m_nSystemByte);

	pMessage->getBody()->setU1(1, "RSDC");
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsSelectedEquipmentStatusRequest(unsigned int SVID)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 1 | REPLY, 3, ++m_nSystemByte);

	pMessage->getBody()->addU4Item(SVID, "SVID");
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsQueryPPIDList()
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 7 | REPLY, 19, ++m_nSystemByte);
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsCarrierActionRequest(unsigned int DATAID, 
	const char* pszCarrierAction, 
	const char* pszCarrierId,
	unsigned char PTN)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 3 | REPLY, 17, ++m_nSystemByte);
	pMessage->getBody()->addU4Item(DATAID, "DATAID");
	pMessage->getBody()->addItem(pszCarrierAction, "CARRIERACTION");
	pMessage->getBody()->addItem(pszCarrierId, "CARRIERID");
	pMessage->getBody()->addU1Item(PTN, "PTN");
	pMessage->getBody()->addItem();
	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsProceedWithCarrier(unsigned int DATAID,
	const char* pszCarrierId,
	unsigned char PTN)
{
	return hsmsCarrierActionRequest(DATAID, "ProceedWithCarrier", pszCarrierId, PTN);
}

int CHsmsActive::hsmsCarrierRelease(unsigned int DATAID,
	const char* pszCarrierId,
	unsigned char PTN)
{
	return hsmsCarrierActionRequest(DATAID, "CarrierRelease", pszCarrierId, PTN);
}

int CHsmsActive::hsmsProceedWithSlotMap(unsigned int DATAID,
	const char* pszCarrierId,
	unsigned char PTN,
	const char* pszLotId,
	const std::vector<std::string>& panelIds,
	const std::vector<unsigned char>& slotMap)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 3 | REPLY, 17, ++m_nSystemByte);
	if (nRet != 0 || pMessage == nullptr) {
		return nRet;
	}

	pMessage->getBody()->addU4Item(DATAID, "DATAID");
	pMessage->getBody()->addItem("ProceedWithSlotMap", "CARRIERACTION");
	pMessage->getBody()->addItem(pszCarrierId, "CARRIERID");
	pMessage->getBody()->addU1Item(PTN, "PTN");

	// Extended params (currently not parsed by Servo side): { LOTID, PANELID_LIST, SLOTMAP_LIST }
	ISECS2Item* pParams = pMessage->getBody()->addItem(); // L
	pParams->addItem(pszLotId != nullptr ? pszLotId : "", "LOTID");

	ISECS2Item* pPanelList = pParams->addItem(); // L
	for (const auto& id : panelIds) {
		pPanelList->addItem(id.c_str(), "PANELID");
	}

	ISECS2Item* pSlotMapList = pParams->addItem(); // L
	for (auto v : slotMap) {
		pSlotMapList->addU1Item(v, "SLOTSTATE");
	}

	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsPRJobMultiCreate(std::vector<SERVO::CProcessJob*>& pjs)
{
	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 16 | REPLY, 15, ++m_nSystemByte);
	char szMF[32] = {14};
	pMessage->getBody()->addU2Item(++DATAID, "DATAID");
	auto itemPjs = pMessage->getBody()->addItem();
	for (auto pj : pjs) {
		auto itemPj = itemPjs->addItem();
		itemPj->addItem(pj->id().c_str(), "PRJOBID");
		itemPj->addBinaryItem(szMF, 1, "MF");
		auto itemCarriers = itemPj->addItem();
		for (auto c : pj->carriers()) {
			auto itemCarrier = itemCarriers->addItem();
			itemCarrier->addItem(c.carrierId.c_str(), "CARRIERID");
			auto itemSlots = itemCarrier->addItem();
			for (auto s : c.slots) {
				itemSlots->addU1Item(s, "SLOTID");
			}
		}

		auto recipeItems = itemPj->addItem();
		recipeItems->addU1Item(1, "PRRECIPEMETHOD");
		recipeItems->addItem(pj->recipeSpec().c_str(), "RCPSPEC");
		recipeItems->addItem();

		itemPj->addBoolItem(false, "PRPROCESSSTART");
		itemPj->addItem();
	}

	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::hsmsCreateControlJob(const char* pszControlJobId, std::vector<std::string>& processJobIds)
{
	char szBuffer[256];
	sprintf_s(szBuffer, 256, "ControlJob:%s>", pszControlJobId);

	IMessage* pMessage = nullptr;
	int nRet = HSMS_Create1Message(pMessage, m_nSessionId, 14 | REPLY, 9, ++m_nSystemByte);
	pMessage->getBody()->addItem(szBuffer, "OBJSPEC");
	pMessage->getBody()->addItem("ControlJob", "OBJTYPE");
	auto itemAttrs = pMessage->getBody()->addItem();

	{
		auto itemAttr = itemAttrs->addItem();
		itemAttr->addItem("Priority", "ATTRID");
		itemAttr->addU1Item(8, "ATTRDATA");
	}

	{
		auto itemAttr = itemAttrs->addItem();
		itemAttr->addItem("weight", "ATTRID");
		itemAttr->addF4Item(60.5, "ATTRDATA");
	}

	{
		auto itemAttr = itemAttrs->addItem();
		itemAttr->addItem("tel", "ATTRID");
		itemAttr->addItem("15919875007", "ATTRDATA");
	}

	{
		auto itemAttr = itemAttrs->addItem();
		itemAttr->addItem("PRJOBLIST", "ATTRID");
		auto itemProcessJobs = itemAttr->addItem();
		for (auto& item : processJobIds) {
			itemProcessJobs->addItem(item.c_str(), "");
		}
	}

	m_pActive->sendMessage(pMessage);
	HSMS_Destroy1Message(pMessage);

	return 0;
}

int CHsmsActive::replyAck0(IMessage* pMessage)
{
	return 0;
}

// 通用的reply ack函数
void CHsmsActive::replyAck(int s, int f, unsigned int systemBytes, BYTE ack, const char* pszAckName)
{
	IMessage* pMessage = NULL;
	HSMS_Create1Message(pMessage, m_nSessionId, s, f, systemBytes);
	ASSERT(pMessage);
	ISECS2Item* pItem = pMessage->getBody();
	pItem->setBinary((const char*)&ack, 1, pszAckName);
	m_pActive->sendMessage(pMessage);
	LOGI("<HSMS>[SECS Msg SEND]S%dF%d (SysByte=%u)", s, f, systemBytes);
	HSMS_Destroy1Message(pMessage);
}