#include "stdafx.h"
#include "HsmsAction.h"


CHsmsAction::CHsmsAction()
{
	m_nAction = ACTION_IDLE;
	m_bNeedWaitReply = FALSE;
	m_nTimeout = 45;
	m_nResponseTime = 0;
	m_pContext = NULL;
	m_pSendMessage = NULL;
	m_hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
}

CHsmsAction::CHsmsAction(int nAction, BOOL bNeedReply, unsigned int nTimeout)
{
	m_nAction = nAction;
	m_bNeedWaitReply = bNeedReply;
	m_nTimeout = nTimeout;
	m_nResponseTime = 0;
	m_pContext = NULL;
	m_pSendMessage = NULL;
	m_hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
}

CHsmsAction::~CHsmsAction()
{
	if (m_hEvent != NULL) {
		CloseHandle(m_hEvent);
		m_hEvent = NULL;
	}

	if (m_pSendMessage != NULL) {
		HSMS_Destroy1Message(m_pSendMessage);
		m_pSendMessage = NULL;
	}
}

void CHsmsAction::reset()
{
	m_nAction = ACTION_IDLE;
	m_bNeedWaitReply = FALSE;
	m_nTimeout = 45;
	m_nResponseTime = 0;
	if (m_pSendMessage != NULL) {
		HSMS_Destroy1Message(m_pSendMessage);
		m_pSendMessage = NULL;
	}
	::ResetEvent(m_hEvent);
}

void CHsmsAction::resetResponseTime()
{
	m_nResponseTime = 0;
}

void CHsmsAction::setAction(int nAction, BOOL bNeedReply/* = TRUE*/, unsigned int nTimeout/* = 45*/)
{
	m_nAction = nAction;
	m_bNeedWaitReply = bNeedReply;
	m_nTimeout = nTimeout;
}

int CHsmsAction::getAction()
{
	return m_nAction;
}

void CHsmsAction::setContext(CContext* pContext)
{
	m_pContext = pContext;
}

CContext* CHsmsAction::getContext()
{
	return m_pContext;
}

void CHsmsAction::setSendMessage(IMessage* pMessage)
{
	if (m_pSendMessage != NULL && m_pSendMessage != pMessage) {
		HSMS_Destroy1Message(m_pSendMessage);
	}
	m_pSendMessage = pMessage;
}

IMessage* CHsmsAction::getSendMessage()
{
	return m_pSendMessage;
}

unsigned int CHsmsAction::getTimeout()
{
	return m_nTimeout;
}

BOOL CHsmsAction::isNeedWaitReply()
{
	return m_bNeedWaitReply;
}

HANDLE CHsmsAction::getEvent()
{
	return m_hEvent;
}

int CHsmsAction::responseTimeIncrement()
{
	return InterlockedIncrement(&m_nResponseTime);
}

BOOL CHsmsAction::incrementAndCheckTimeout()
{
	unsigned int nResponseTime = InterlockedIncrement(&m_nResponseTime);
	return nResponseTime >= m_nTimeout + 1;
}

int CHsmsAction::serialize(char* pszBuffer, int nBufferSize)
{
	int index = 0;
	if (m_pSendMessage == NULL) {
		return 0;
	}
	if (pszBuffer == nullptr) {
		index += sizeof(int);
		index += sizeof(m_nTimeout);
		index += sizeof(int);
		index += sizeof(BOOL);
		index += m_pSendMessage->serialize(nullptr, 0);

		return index;
	}
	else {
		memcpy(&pszBuffer[index], &m_nAction, sizeof(int));
		index += sizeof(int);

		memcpy(&pszBuffer[index], &m_nTimeout, sizeof(int));
		index += sizeof(int);

		memcpy(&pszBuffer[index], &m_nResponseTime, sizeof(int));
		index += sizeof(int);

		memcpy(&pszBuffer[index], &m_bNeedWaitReply, sizeof(BOOL));
		index += sizeof(BOOL);

		index += m_pSendMessage->serialize(&pszBuffer[index], nBufferSize - index);

		return index;
	}
}

int CHsmsAction::unserialize(const char* pszBuffer, int nBufferSize)
{
	int index = 0;
	if (index + sizeof(int) > nBufferSize) return -1;
	memcpy(&m_nAction, &pszBuffer[index], sizeof(int));
	index += sizeof(int);

	if (index + sizeof(int) > nBufferSize) return -1;
	memcpy(&m_nTimeout, &pszBuffer[index], sizeof(int));
	index += sizeof(int);

	if (index + sizeof(int) > nBufferSize) return -1;
	memcpy(&m_nResponseTime, &pszBuffer[index], sizeof(int));
	index += sizeof(int);

	if (index + sizeof(BOOL) > nBufferSize) return -1;
	memcpy(&m_bNeedWaitReply, &pszBuffer[index], sizeof(BOOL));
	index += sizeof(BOOL);

	if (m_pSendMessage != NULL) {
		HSMS_Destroy1Message(m_pSendMessage);
		m_pSendMessage = NULL;
	}
	if (HSMS_Create1Message(m_pSendMessage, 1, 1 | REPLY, 1, 1) != 0 || m_pSendMessage == NULL) {
		return -1;
	}
	int nRet = m_pSendMessage->unserialize(&pszBuffer[index], nBufferSize - index);
	if (nRet < 0) return nRet;

	return index + nRet;
}