#include "StdAfx.h"
#include ".\packethandler.h"
#include "Handler_SM.h"
#include "Handler_SA.h"
#include "Handler_SMA.h"
#include <Protocol_SM.h>
#include <Protocol_SA.h>
#include <protocol_SMA.h>
#include <Protocol_AT.h>
#include "UserSession.h"
#include "ServerSession.h"


PacketHandler::PacketHandler(void)
{
	m_pFunctionMapSM = new FunctionMap;
	m_pFunctionMapSA = new FunctionMap;
	m_pFunctionMapSMA = new FunctionMap;

	RegisterHandler();
}

PacketHandler::~PacketHandler(void)
{
	if( m_pFunctionMapSM )
	{
		m_pFunctionMapSM->Release();
		delete	m_pFunctionMapSM;
	}

	if( m_pFunctionMapSA )
	{
		m_pFunctionMapSA->Release();
		delete	m_pFunctionMapSA;
	}

	if( m_pFunctionMapSMA )
	{
		m_pFunctionMapSMA->Release();
		delete	m_pFunctionMapSMA;
	}

	m_pFunctionMapSM = NULL;
	m_pFunctionMapSA = NULL;
	m_pFunctionMapSMA = NULL;
}


//핸들러를 등록시킨다. 이 클래스가 생성될때.. 하도록 하자.
BOOL PacketHandler::RegisterHandler()
{
	if( !RegisterHandler_SM() )		return	FALSE;
	if( !RegisterHandler_SA() )		return	FALSE;
	if( !RegisterHandler_SMA() )	return	FALSE;

	return TRUE;
}


BOOL PacketHandler::RegisterHandler_SM()
{
	//User
	AddHandler_SM( SM_USER, SM_USER_REGISTER_SYN, Handler_SM::OnHandler_SM_USER_REGISTER_SYN );
	AddHandler_SM( SM_USER, SM_USER_MODIFY_PASSWORD_SYN, Handler_SM::OnHandler_SM_USER_MODIFY_PASSWORD_SYN );
	AddHandler_SM( SM_USER, SM_USER_IDLIST_REQ_SYN, Handler_SM::OnHandler_SM_USER_IDLIST_REQ_SYN );

	//Server
	AddHandler_SM( SM_SERVER, SM_SERVER_REGISTER_SYN, Handler_SM::OnHandler_SM_SERVER_REGISTER_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_EXECUTE_SYN, Handler_SM::OnHandler_SM_SERVER_EXECUTE_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_SHUTDOWN_SYN, Handler_SM::OnHandler_SM_SERVER_SHUTDOWN_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_BACKUP_SYN, Handler_SM::OnHandler_SM_SERVER_BACKUP_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_RESTORE_SYN, Handler_SM::OnHandler_SM_SERVER_RESTORE_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_FORCE_DISCONNECT_SYN, Handler_SM::OnHandler_SM_SERVER_FORCE_DISCONNECT_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_ACCESS_RIGHT_REQ_SYN, Handler_SM::OnHandler_SM_SERVER_ACCESS_RIGHT_REQ_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_ACCESS_RIGHT_SAVE_SYN, Handler_SM::OnHandler_SM_SERVER_ACCESS_RIGHT_SAVE_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_ACCESS_RIGHT_INIT_SYN, Handler_SM::OnHandler_SM_SERVER_ACCESS_RIGHT_INIT_SYN );

    //Notice
    AddHandler_SM( SM_SERVER, SM_SERVER_NOTICE_SYN, Handler_SM::OnHandler_SM_SERVER_NOTICE_SYN );
    AddHandler_SM( SM_SERVER, SM_SERVER_SEND_NOTICE_SYN, Handler_SM::OnHandler_SM_SERVER_SEND_NOTICE_SYN );
    
	//Patch
	AddHandler_SM( SM_PATCH, SM_PATCH_UPLOAD_NTF, Handler_SM::OnHandler_SM_PATCH_UPLOAD_NTF );
	AddHandler_SM( SM_PATCH, SM_PATCH_EXECUTE_SYN, Handler_SM::OnHandler_SM_PATCH_EXECUTE_SYN );

	//Check
	AddHandler_SM( SM_CHECK, SM_CHECK_LOGFILE_SYN, Handler_SM::OnHandler_SM_CHECK_LOGFILE_SYN );

	//Agent
	AddHandler_SM( SM_AGENT, SM_AGENT_INFO_REQ_SYN, Handler_SM::OnHandler_SM_AGENT_INFO_REQ_SYN );
	AddHandler_SM( SM_AGENT, SM_AGENT_REGISTER_SYN, Handler_SM::OnHandler_SM_AGENT_REGISTER_SYN );
	AddHandler_SM( SM_AGENT, SM_AGENT_DELETE_SYN, Handler_SM::OnHandler_SM_AGENT_DELETE_SYN );
	AddHandler_SM( SM_AGENT, SM_AGENT_MODIFY_SYN, Handler_SM::OnHandler_SM_AGENT_MODIFY_SYN );

	//.//

	//////////////////////////////////////////////////////////////////////////
#ifdef __20080312__SOLARAUTH_SERVER_PATCH
	AddHandler_SM( SM_SERVER, SM_SERVER_SOLARSCRIPT_BACKUP_SYN, Handler_SM::OnHandler_SM_SERVER_SOLARSCRIPT_BACKUP_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_SOLARSCRIPT_RESTORE_SYN, Handler_SM::OnHandler_SM_SERVER_SOLARSCRIPT_RESTORE_SYN );
	AddHandler_SM( SM_PATCH, SM_PATCH_SOLARSCRIPT_EXECUTE_SYN, Handler_SM::OnHandler_SM_PATCH_SOLARSCRIPT_EXECUTE_SYN );
	AddHandler_SM( SM_SERVER, SM_SERVER_SOLARSCRIPT_CONVERT_SYN, Handler_SM::OnHandler_SM_SERVER_SOLARSCRIPT_CONVERT_SYN );
#endif //__20080312__SOLARAUTH_SERVER_PATCH
	//////////////////////////////////////////////////////////////////////////

	return TRUE;
}

BOOL PacketHandler::RegisterHandler_SA()
{
	// Server
	AddHandler_SA( SA_SERVER, SA_SERVER_AUTH_SYN, Handler_SA::OnHandler_SA_SERVER_AUTH_SYN );
	AddHandler_SA( SA_SERVER, SA_SERVER_EXECUTE_ACK, Handler_SA::OnHandler_SA_SERVER_EXECUTE_ACK );
	AddHandler_SA( SA_SERVER, SA_SERVER_BACKUP_ACK, Handler_SA::OnHandler_SA_SERVER_BACKUP_ACK );
	AddHandler_SA( SA_SERVER, SA_SERVER_RESTORE_ACK, Handler_SA::OnHandler_SA_SERVER_RESTORE_ACK );
	AddHandler_SA( SA_SERVER, SA_SERVER_FORCE_DISCONNECT_ACK, Handler_SA::OnHandler_SA_SERVER_FORCE_DISCONNECT_ACK );

    // Notice
    AddHandler_SA( SA_SERVER, SA_SERVER_NOTICE_ACK, Handler_SA::OnHandler_SA_SERVER_NOTICE_ACK );
    AddHandler_SA( SA_SERVER, SA_SERVER_SEND_NOTICE_ACK, Handler_SA::OnHandler_SA_SERVER_SEND_NOTICE_ACK );

	// Patch
	AddHandler_SA( SA_PATCH, SA_PATCH_EXECUTE_ACK, Handler_SA::OnHandler_SA_PATCH_EXECUTE_ACK );
	AddHandler_SA( SA_PATCH, SA_PATCH_RESULT_NTF, Handler_SA::OnHandler_SA_PATCH_RESULT_NTF );

	// Check
	AddHandler_SA( SA_CHECK, SA_CHECK_LOGFILE_ACK, Handler_SA::OnHandler_SA_CHECK_LOGFILE_ACK );
	AddHandler_SA( SA_CHECK, SA_CHECK_GAMEPROCESS_NTF, Handler_SA::OnHandler_SA_CHECK_GAMEPROCESS_NTF );

#ifdef __20080312__SOLARAUTH_SERVER_PATCH
	AddHandler_SA( SA_SERVER, SA_SOLARSCRIPT_BACKUP_ACK, Handler_SA::OnHandler_SA_SOLARSCRIPT_BACKUP_ACK);
	AddHandler_SA( SA_SERVER, SA_SOLARSCRIPT_RESTORE_ACK, Handler_SA::OnHandler_SA_SOLARSCRIPT_RESTORE_ACK);
	AddHandler_SA( SA_SERVER, SA_SOLARSCRIPT_EXECUTE_ACK, Handler_SA::OnHandler_SA_SOLARSCRIPT_EXECUTE_ACK);
#endif

#ifdef _NA_006543_20130318_HEARTBEAT
	AddHandler_SA(SA_CHECK, SA_CHECK_HEARTBEAT, Handler_SA::OnHandler_SA_CHECK_HEARTBEAT_NTF);
#endif
	return TRUE;
}


BOOL PacketHandler::RegisterHandler_SMA()
{
	AddHandler_SMA( MO_OPERATION, MO_RTTG_SERVERSHUTDOWN_ANS, Handler_SMA::OnHandler_MO_RTTG_SERVERSHUTDOWN_ANS );
	AddHandler_SMA( MO_OPERATION, MO_RTTG_ALL_SERVER_STATUS_NTF, Handler_SMA::OnHandler_MO_RTTG_ALL_SERVER_STATUS_NTF );

	return TRUE;
}

BOOL PacketHandler::AddHandler_SM( BYTE byCategory, BYTE byMsgType, fnUserHandler pHandler )
{
	FUNC_SM*	pFuncSM = new FUNC_SM;
	pFuncSM->m_wFuncKey = MAKEWORD( byCategory, byMsgType );
	pFuncSM->m_fnHandler = pHandler;

	return m_pFunctionMapSM->Add( pFuncSM );
}

BOOL PacketHandler::AddHandler_SA( BYTE byCategory, BYTE byMsgType, fnHandler pHandler )
{
	FUNC_SA*	pFuncSA = new FUNC_SA;
	pFuncSA->m_wFuncKey = MAKEWORD( byCategory, byMsgType );
	pFuncSA->m_fnHandler = pHandler;

	return m_pFunctionMapSA->Add( pFuncSA );
}

BOOL PacketHandler::AddHandler_SMA( BYTE byCategory, BYTE byMsgType, fnHandler pHandler )
{
	FUNC_SMA*	pFuncSMA = new FUNC_SMA;
	pFuncSMA->m_wFuncKey = MAKEWORD( byCategory, byMsgType );
	pFuncSMA->m_fnHandler = pHandler;

	return m_pFunctionMapSMA->Add( pFuncSMA );
}

//만일 해당하는 곳마다 MSG_BASE가 틀리다면... 인자값을 MSG_BASE가 아니라, BYTE로 하고
//함수 자체 내에서 타입캐스팅 해주는게 낳을지 모른다.
BOOL PacketHandler::ParserPacket_SM( UserSession* pSession, MSG_BASE* pMsg, int nSize )
{
	if( !pMsg )			return FALSE;

	FUNC_SM*	pFunc = (FUNC_SM*)m_pFunctionMapSM->Find( MAKEWORD( pMsg->m_byCategory, pMsg->m_byProtocol ) );
	if( !pFunc )		return FALSE;

	//함수 실행
	pFunc->m_fnHandler( pSession, pMsg, nSize );

	return TRUE;
}

BOOL PacketHandler::ParserPacket_SA( ServerSession* pSession, MSG_BASE* pMsg, int nSize )
{
	if( !pMsg )			return FALSE;

	FUNC_SA*	pFunc = (FUNC_SA*)m_pFunctionMapSA->Find( MAKEWORD( pMsg->m_byCategory, pMsg->m_byProtocol ) );
	if( !pFunc )		return FALSE;

	//함수 실행
	pFunc->m_fnHandler( pSession, pMsg, nSize );

	return TRUE;
}

BOOL PacketHandler::ParserPacket_SMA( ServerSession* pSession, MSG_BASE* pMsg, int nSize )
{
	if( !pMsg )			return FALSE;

	FUNC_SMA*	pFunc = (FUNC_SMA*)m_pFunctionMapSMA->Find( MAKEWORD( pMsg->m_byCategory, pMsg->m_byProtocol ) );
	if( !pFunc )		return FALSE;

	//함수 실행
	pFunc->m_fnHandler( pSession, pMsg, nSize );

	return TRUE;
}