#pragma once

#include "WiseDefines.h"

#pragma pack(push,1)

template<typename DWORD _MAX_MSG_SIZE>
struct MSG_BUFFER
{
	MSG_BUFFER() : MAGIC_CODE_HDR(MAGIC_MEMORY_IDS_MARK), MAGIC_CODE_TAIL(MAGIC_MEMORY_IDS_MARK),
		DUMMY_PADDER(0), BUFFER_HDR_PADDER1(0), BUFFER_HDR_PADDER2(0)
	{}

	template<typename _TY>
	inline _TY& InstanceOf()
	{
		DEFINE_CONST _TY_SIZE = sizeof(_TY);

		ZeroMemory(MSG_STREAM, _TY_SIZE);
		MAGIC_CODE_EXPOSURE(&MSG_STREAM[_TY_SIZE]) = MAGIC_MEMORY_IDS_MARK;
		_TY* pTYPE = new (MSG_STREAM) _TY;
		return *(pTYPE);
	}

	template<typename _TY>
	inline static _TY& TypeOf()
	{
		return *((_TY*)MSG_STREAM);
	}

	inline BOOL			IntegrityCheck()
	{
		BOOL bRET = TRUE;
		bRET = bRET && (MAGIC_CODE_HDR == MAGIC_MEMORY_IDS_MARK);
		bRET = bRET && (MAGIC_CODE_TAIL == MAGIC_MEMORY_IDS_MARK);

		return bRET;
	}

	inline void			Refresh()
	{
		MAGIC_CODE_HDR = MAGIC_MEMORY_IDS_MARK;
		MAGIC_CODE_TAIL = MAGIC_MEMORY_IDS_MARK;
	}

	MAGIC_CODE_T		MAGIC_CODE_HDR;
	WORD				DUMMY_PADDER;
	BYTE				BUFFER_HDR_PADDER1;
	BYTE				BUFFER_HDR_PADDER2;
	BYTE				MSG_STREAM[_MAX_MSG_SIZE];
	MAGIC_CODE_T		MAGIC_CODE_TAIL;
};

template<typename _TY_MSGBUF>
struct MSG_BUFFER_CRYPT
{
	_TY_MSGBUF&		BUFFER_REF;

	MSG_BUFFER_CRYPT(_TY_MSGBUF& refBase) : BUFFER_REF(refBase) {}

	template<typename _TY>
	inline _TY& TypeOf()
	{
		return *((_TY*)&(BUFFER_REF.BUFFER_HDR_PADDER1));
	}

	inline BYTE&	SNKEY() { return BUFFER_REF.BUFFER_HDR_PADDER1; }
	inline BYTE&	CRC() { return BUFFER_REF.BUFFER_HDR_PADDER2; }
	inline BYTE*	MSG_ROOT_PTR() { return &BUFFER_REF.BUFFER_HDR_PADDER1; }
	inline BYTE*	MSG_HDR_PTR() { return BUFFER_REF.MSG_STREAM; }
};

struct CRYPT_PACKET_STRUCTURE
{
	BYTE		SNKEY;
	BYTE		CRC;
	MSG_BASE	MSG_HDR[1];

	template<typename _TY>
	inline _TY& InstanceOf()
	{
		DEFINE_CONST _TY_SIZE = sizeof(_TY);
		ZeroMemory(MSG_HDR, _TY_SIZE);
		_TY* pTYPE = new (MSG_HDR) _TY;
		*(DWORD*)&((BYTE*)MSG_HDR)[_TY_SIZE] = MAGIC_MEMORY_IDS_MARK;
		return *(pTYPE);
	}

	template<typename _TY>
	inline static _TY& TypeOf()
	{
		return *((_TY*)MSG_HDR);
	}

	inline BOOL			IntegrityCheck()
	{
		BOOL bRET = TRUE;
		return bRET;
	}
};

#pragma pack(pop)

typedef MSG_BUFFER<8200>		USER_MSG_BLOCK_L;
typedef MSG_BUFFER<2000>		USER_MSG_BLOCK_S;


typedef MSG_BUFFER_CRYPT<USER_MSG_BLOCK_L>	CRYPT_MSG_RECV;
typedef MSG_BUFFER_CRYPT<USER_MSG_BLOCK_S>	CRYPT_MSG_SEND;