#include "stdafx.h"

#include "PacketHandler.h"

#include <PacketControl/PacketControl.h>

#include "Handler_CW.h"
#include "Handler_CG.h"
#include "Handler_CL.h"


//-------------------------------------------------------
// MODULE VARIABLE
static PACKET_HANDLER_DELEGATOR		s_pPacketHandler = NULL;

PacketHandler::PacketHandler()
{
	_Initialize();
}

PacketHandler::~PacketHandler()
{
	for(DWORD i=0 ; i<MAX_SESSION ; ++i)
	{
		SAFE_DELETE(m_FuncMaps[i].REFERENCE());
	}
}

PACKET_HANDLER_DELEGATOR	PacketHandler::GetHandler()
{
	return s_pPacketHandler;
}

void	PacketHandler::_Initialize()
{
	_Locking();

	memset(m_FuncMaps, 0, sizeof(m_FuncMaps));

	m_FuncMaps[AGENT_SESSION] = new FunctionMap();
	m_FuncMaps[WORLD_SESSION] = new FunctionMap();
	m_FuncMaps[LOGIN_FRONT_SESSION] = new FunctionMap();

    nsPacket::Environment::Init();
}

void	PacketHandler::ClosePacketHandler()
{
	SAFE_DELETE(s_pPacketHandler.REFERENCE());
}

void	PacketHandler::RegisterHandler()
{
	if(s_pPacketHandler() == NULL)
	{
		s_pPacketHandler = new PacketHandler();
	}

	s_pPacketHandler->_UnLocking();
	Handler_CL::RegisterHandler_ALL(s_pPacketHandler);
	Handler_CG::RegisterHandler_ALL(s_pPacketHandler);
	Handler_CW::RegisterHandler_ALL(s_pPacketHandler);
	s_pPacketHandler->_Locking();
}

BOOL	PacketHandler::RegisterHandler(eCONNECT_SESSIONS idxSession, sPACKET_HANDLER_INFO* pINFOs)
{
	if(_IsLock())
		return FALSE;

	sPACKET_HANDLER_INFO* pOffset = pINFOs;

	BOOL bResult = TRUE;

	if((DWORD)MAX_SESSION > (DWORD)idxSession)
	{
		FUNCTION_MAP_DELEGATOR& rFuncMap = m_FuncMaps[idxSession];
		if(rFuncMap != NULL)
		{
			for(; pOffset ; ++pOffset)
			{
				if(pOffset->pfnHandler)
				{
					FUNC_GENERIC_DELEGATOR func = new FUNC_GENERIC;
					func->m_dwFunctionKey = pOffset->wCATEGORYnPROTOCOL;
					func->m_fnHandler = pOffset->pfnHandler;
					bResult = rFuncMap->Add(func());
					if(!bResult)
						break;
				}
				else if(!(pOffset->wCATEGORYnPROTOCOL))
				{
					break;
				}
			}
		}
		else
			bResult = FALSE;
	}
	else
		bResult = FALSE;

	if(!bResult)
	{
		BYTE byCategory = (BYTE)(pOffset->wCATEGORYnPROTOCOL&0xFF);
		BYTE byProtocol = (BYTE)((pOffset->wCATEGORYnPROTOCOL>>8)&0xFF);

		MessageOutEx(g_pSunLog, CSunLog::cCRITICAL_LOG, CSunLog::cOUTPUT_BOTH, CSunLog::cCATE_CONNECTION,
			_T("Can't Register %u Packet Handler [C:%03u][P:%03u]"),
			idxSession, byCategory, byProtocol);
	}

	return bResult;
}

//
//
//
inline
BOOL	PacketHandler::CanDoProcess(FUNC_GENERIC_DELEGATOR& funcDelegator)
{
	if(funcDelegator == NULL)
	{
		return FALSE;
	}
	return TRUE;
}
//
//
//

BOOL	PacketHandler::ParsePacket(eCONNECT_SESSIONS idxSession, ServerSession* pSession, WiseUser* pUser, sSIG_NETMSG* pSIG_NETMSG)
{
	MSG_BASE* pBASE = (MSG_BASE*)pSIG_NETMSG->MSG_HDR();

	if((DWORD)MAX_SESSION > (DWORD)idxSession)
	{
		FUNCTION_MAP_DELEGATOR& rFuncMap = m_FuncMaps[idxSession];
		if(rFuncMap != NULL)
		{
			WORD wCP = MAKEWORD(pBASE->m_byCategory, pBASE->m_byProtocol);

			FUNC_GENERIC_DELEGATOR fnINFO = (FUNC_GENERIC*)rFuncMap->Find(wCP);

			if(CanDoProcess(fnINFO))
			{
				fnINFO->m_fnHandler(pSession, pUser, pSIG_NETMSG);
				return TRUE;
			}
		}
	}

	MessageOutEx(g_pSunLog, CSunLog::cCRITICAL_LOG, CSunLog::cOUTPUT_BOTH, CSunLog::cCATE_CONNECTION,
		_T("%u Handler Null, Invalid Type, UnAuthorized [C:P=%03d:%03d]"),
		idxSession, pBASE->m_byCategory, pBASE->m_byProtocol);

	return FALSE;
}

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

BOOL
PACKET_CONTROL::m_bShowPacketStream = FALSE;

const CPShowFNTable*
PACKET_CONTROL::m_CPShowHandler = NULL;

const struct sFLOW_CODE
{
	CHAR*	flow;
} s_FLOW_CODE[4] = 
{
#define TO_CODE(pstr)	pstr
	TO_CODE("C2G"),
	TO_CODE("G2C"),
	TO_CODE("W2C"),
	TO_CODE("C2W"),
#undef TO_CODE
};

void
PACKET_CONTROL::SetShowPacketStream(BOOL bSet)
{
	m_bShowPacketStream = bSet;
	m_CPShowHandler = GetCPShowHandler();
	m_CPShowHandler->fnInit(C2S_HIGH_VERSION_NO, C2S_MIDDLE_VERSION_NO, CATEGORY_ODD_NUMBER, PROTOCOL_ODD_NUMBER);
}

void
PACKET_CONTROL::ShowPacketStream(MSG_BASE* pBASE, WORD wSize, CHAR* pPrefix)
{
	if(!GetShowPacketStream())
		return;

#define TO_CODE(num)	(*(DWORD*)(s_FLOW_CODE[(num)].flow))
#define TO_CODE_STK(pstr)	(*(DWORD*)(pstr))

	DWORD dwPrefix = TO_CODE_STK(pPrefix);
	dwPrefix = (TO_CODE(0) == dwPrefix) ? 1
		: (TO_CODE(1) == dwPrefix) ? 1
		: (TO_CODE(2) == dwPrefix) ? 1
		: (TO_CODE(3) == dwPrefix) ? 1
		: 2;

	WORD wPacket = MAKEWORD(pBASE->m_byCategory, pBASE->m_byProtocol);

	CHAR str[1024*32];
	INT iWritten = 0;
	if(wSize > 10000)
	{
		//SUNLOG(eCRITICAL_LOG, "¸»µµ ¾ÈµÇ°Ô Å« ÆÐŶÀÌ ¼Û½Å ¶Ç´Â ¼ö½ÅµÇ¾ú´Ù.");
		return;
	}

	BOOL bShowCPNumber = TRUE;
	if(m_CPShowHandler && (dwPrefix == 1))
	{
		// Ŭ¶ó´Â 4¹ÙÀÌÆ® ª´Ù.
		//pBASE = (MSG_BASE*)(((BYTE*)pBASE)-sizeof(DWORD));
		const CHAR* pMSG_STR = m_CPShowHandler->fnQuery(pBASE->m_byCategory, pBASE->m_byProtocol, NULL);
		bShowCPNumber = (pMSG_STR) ? FALSE : TRUE;

		if(!bShowCPNumber)
			iWritten = _snprintf(str, 200, "[%s]\tS(%03d)\t%s",
			pPrefix, wSize, pMSG_STR
			);
	}

	if(bShowCPNumber)
		iWritten = _snprintf(str, 200, "[%s]\tS(%03d)\tC(%03d)\tP(%03d)",
						pPrefix, wSize, pBASE->m_byCategory, pBASE->m_byProtocol
						);

	str[iWritten++] = '\0';
	if('\0' != str[0])
		puts(str);
}