#pragma once

#include "GameObject.h"
#include <Sessions/UserSessionMgr.h>

//////////////////////////////////////////////////////////////////////////
//
class WiseUser;

#pragma pack(push, 1)

template<eWISESUBTYPE _MSGTYPE, typename _TyMSG_BUFFER>
struct sMESSAGE_BLOCK
{
	sSIG_NETMSG			SIG_NETWORK_MESSAGE_REF[1];
	_TyMSG_BUFFER		MESSAGE_BLOCK;

	sMESSAGE_BLOCK()
	{
		SIG_NETWORK_MESSAGE_REF->MSG_LEN() = 0;
		ReFresh();
	}

	inline BOOL			Store(ServerSession* pSession, WiseUser* pUser, BYTE* pMsg, WORD wSize)
	{
		// Size°Ë»ç¿¡¼­ Packet Max Size + 4ÀÇ °ø°£ÀÌ °¨¾ÈµÇ¾î¾ß ÇÑ´Ù.
		if(!(pUser && pSession && pMsg && ((DWORD)wSize < sizeof(MESSAGE_BLOCK.MSG_STREAM))))
		{
			DEBUGGING_CODE_L1("Invalid Store Info");
			return FALSE;
		}

		SIG_NETWORK_MESSAGE_REF->USER() = pUser;
		SIG_NETWORK_MESSAGE_REF->SESSION_PTR() = pSession;
		SIG_NETWORK_MESSAGE_REF->MSG_HDR() = MESSAGE_BLOCK.MSG_STREAM;
		SIG_NETWORK_MESSAGE_REF->MSG_LEN() = wSize;

		if(SIG_NETWORK_MESSAGE_REF->MSG_HDR() != pMsg)
			CopyMemory(SIG_NETWORK_MESSAGE_REF->MSG_HDR(), pMsg, wSize);
		MAGIC_CODE_EXPOSURE(&(MESSAGE_BLOCK.MSG_STREAM[wSize])) = MAGIC_MEMORY_IDS_MARK;

		return TRUE;
	}

	template<typename _TY>
	inline _TY& InstanceOf()
	{ return MESSAGE_BLOCK.InstanceOf<_TY>(); }

	template<typename _TY>
	inline static _TY& TypeOf()
	{ return MESSAGE_BLOCK.TypeOf<_TY>(); }

	inline BOOL			IntegrityCheck()
	{
		BOOL bRET = MESSAGE_BLOCK.IntegrityCheck();
		bRET = bRET && (MAGIC_MEMORY_IDS_MARK == MAGIC_CODE_EXPOSURE(&MESSAGE_BLK[SIG_NETWORK_MESSAGE_REF->MSG_LEN()]));

		return bRET;
	}

	inline BOOL			ReFresh()
	{
		SIG_NETWORK_MESSAGE_REF->SUBTYPE() = _MSGTYPE;
		SIG_NETWORK_MESSAGE_REF->USER() = NULL;
		SIG_NETWORK_MESSAGE_REF->SESSION_PTR() = NULL;
		SIG_NETWORK_MESSAGE_REF->MSG_HDR() = MESSAGE_BLOCK.MSG_STREAM;
		WORD wSize = SIG_NETWORK_MESSAGE_REF->MSG_LEN();
		SIG_NETWORK_MESSAGE_REF->MSG_LEN() = 0;

		MESSAGE_BLOCK.Refresh();

		if(!(wSize > sizeof(MESSAGE_BLOCK.MSG_STREAM)))
			ZeroMemory(MESSAGE_BLOCK.MSG_STREAM, wSize);
		else
		{
			DEBUGGING_CODE_L1("Need Check Overflow!");
			ZeroMemory(MESSAGE_BLOCK.MSG_STREAM, sizeof(MESSAGE_BLOCK.MSG_STREAM));
		}

		return TRUE;
	}
};
#pragma pack(pop)

//////////////////////////////////////////////////////////////////////////
// <MSG PROCESSOR>
//
class MsgHandler
{
private:	MsgHandler();
			~MsgHandler();

public:		static void				CreateInstance();
			static void				DestroyInstance();
			static MsgHandler*		Instance() { return ms_pInstance; }

			BOOL					OnMsg(sSIG_WISEBASE* pSIG_MSG, GameObject* pObject);

private:	void					_Initialize();
public:
			typedef BOOL (*MessageHandler)(sSIG_WISEBASE* pSIG_MSG, GameObject* pObject);
			//typedef std::map<eWISESUBTYPE, MessageHandler>	SIGHANDLER_MAP;
			//typedef SIGHANDLER_MAP::iterator			SIGHANDLER_MAP_IT;

			typedef STLX_MAP<DWORD, MessageHandler>			SIGMSG_MAP;
			typedef SIGMSG_MAP::iterator				SIGMSG_MAP_IT;
private:
			SIGMSG_MAP				m_SIGMSG;

private:	static MsgHandler*		ms_pInstance;
};

//////////////////////////////////////////////////////////////////////////
//