#include "StdAfx.h"
#include ".\handler_AW.h"
#include "WorldServer.h"
#include "AgentServerSession.h"
#include "UserFactory.h"
#include "UserManager.h"
#include "WaitingUserList.h"
#include "Channel.h"
#include "ChannelManager.h"
#include "ServerSessionManager.h"
#include <PacketStruct_AW.h>
#include <Protocol_AW.h>
#include <PacketStruct_MW.h>
#include <Protocol_ServerCommon.h>
#include <PacketStruct_ServerCommon.h>

//Ä£±¸ Ãßõ À̺¥Æ® ¶§¹®¿¡
#include "FriendInvitation/WFriendInvitationController.h"

//¸¶½ºÅÍ ¼­¹ö Åë½Å ¶§¹®
#include "WorldServerInfoParser.h"

// ÆÄƼ °ü·Ã ±â´Éµé ¶§¹®
//#include "Party.h"
#include "BaseZone.h"
#include "PartyManager.h"

// Ä£±¸ ¸ñ·Ï ¼ö½Å ¶§¹®
#include <Protocol_DW.h>
#include <PacketStruct_DW.h>

// GM¸í·É ¶§¹®
#include <Protocol_CW.h>
#include <PacketStruct_CW.h>

// ±æµå º¹±¸ ¶§¹®
#include "WorldGuildManager.h"
#include "WorldGuild.h"
#include <PacketStruct_WZ.h>
// ±×·ì¸Î±â ½Ã½ºÅÛ 
#include "GroupManager.h"
//Çع決ÀÇ Æ÷°í¹®
#include <ProhibitionWordParser.h>

#include "GMCmdManager.h"
#include <SSQ/SSQPacketProcS2S.h>

#include "Lotto/Lotto.h"

#include "WorldSystemMemo.h"

GMCmdManager	Handler_AW::m_GMCmdManager;


VOID Handler_AW::OnAW_AGENTSERVER_INFO_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_AGENTSERVER_INFO_SYN *pRecvMsg = (MSG_AW_AGENTSERVER_INFO_SYN*)pMsg;

/*
#ifdef _DEBUG
	assert( pRecvMsg->dwChannelID > 0 && pRecvMsg->dwChannelID < 10 );
#else
	if( pRecvMsg->dwChannelID <= 0 || pRecvMsg->dwChannelID >= 10 )
	{
		MessageOut( eCRITICAL_LOG, "AGENTSERVER_INFO_SYN Error - ä³Î À妽º ¿À·ù![%u]", pRecvMsg->dwChannelID );
		pAgentServer->Disconnect();
		return;
	}
#endif
*/

	//if(pRecvMsg->dwChannelID == 0)
	//	pRecvMsg->dwChannelID = 1;

	if( ChannelManager::Instance()->GetChannel( pRecvMsg->dwChannelID ) != NULL )
	{
		MessageOut(eCRITICAL_LOG,  "Channel(%d) Already Exist...Disconnect", pRecvMsg->dwChannelID );
		pAgentServer->Disconnect();
		return;
	}

	pAgentServer->SetChannelID( pRecvMsg->dwChannelID );

	SERVER_KEY serverKey;

	serverKey.Set( (BYTE)WorldServer::Instance()->GetWorldID(), (BYTE)pRecvMsg->dwChannelID, AGENT_SERVER, 1 );
	pAgentServer->SetServerKey( (DWORD)serverKey );

	ChannelManager::Instance()->AddChannel( pRecvMsg->dwChannelID );
/*
	// Ȥ½Ã ³»°¡ Á×¾ú¾ú´ø °Å¾ß?
	MSG_AW_USER_RESTORE_SYN	sendMsg;

	sendMsg.m_byCategory = AW_USER_STATUS;
	sendMsg.m_byProtocol = AW_USER_RESTORE_SYN;
	sendMsg.m_dwKey = WorldServer::Instance()->GetServerKey();

	// ±×·³ º¹±¸ Á» ÇØÁà¹Ù¹Ù...
	pAgentServer->Send( (BYTE*)&sendMsg, sizeof(sendMsg) );
*/
}

VOID Handler_AW::OnAW_PREPARE_NEW_USER_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_PREPARE_NEW_USER_SYN *pRecvMsg = (MSG_AW_PREPARE_NEW_USER_SYN*)pMsg;

	User *pUser;

	if( pAgentServer->GetChannelID() == 0 )
	{
		MessageOut(eCRITICAL_LOG,  "Not Setted Channel ID - Send to AgentServer AW_PREPARE_NEW_USER_NAK" );
		MessageOut(eCRITICAL_LOG,  "°³¹ß¹èÆ÷¿¡¼­ ³ª¿À´Â ¸Þ½ÃÁö´Â ¹®Á¦¾ø½À´Ï´Ù.~ ³Ñ¾î°¡ÁÖ¼À");
		//MSG_AW_PREPARE_NEW_USER_NAK nakMsg;
		//nakMsg.m_dwKey = pRecvMsg->m_dwKey;
		//pAgentServer->Send( (BYTE*)&nakMsg, sizeof(nakMsg) );
		//return;
	}

	// ÇØ´ç À¯Á®°¡ ÀÌ¹Ì ÀÖ´Â °æ¿ì Á¢¼ÓÀ» ²÷´Â´Ù.
	if( pUser = UserManager::Instance()->FindUser( pRecvMsg->dwUserGuid ) )
	{
		MessageOut(eCRITICAL_LOG, "Duplicated guid! Disconnect Connected User(%s:%u)", pUser->GetCharName().c_str(), pUser->GetGUID() );
		pUser->Logout();
		return;
	}

	// ¾×Ƽºê À¯Á® ÇÒ´ç
	pUser = UserFactory::Instance()->Alloc( ACTIVE_USER );

//	pUser->Init();

	// À¯Á® Á¤º¸ ¼ÂÆÃ
	pUser->SetGUID( pRecvMsg->dwUserGuid );
	pUser->SetChannelID( pAgentServer->GetChannelID() );
	pUser->SetAccountID( pRecvMsg->ptszAccountID );
//	pUser->SetStatus( (eZONETYPE)pRecvMsg->byUserStatus );
	pUser->SetPCRoomID( pRecvMsg->dwPCRoomID );

	// ÀÎÁõµÈ IP ¼ÂÆÃ
	pUser->SetAuthIP( pRecvMsg->szClientIP );
	pUser->SetAuthID( pRecvMsg->dwAuthUserID );

	MessageOut(eFULL_LOG, "PREPARE_NEW_USER_SYN[Channel:%u][Guid:%u][IP:%s]", pUser->GetChannelID(), 
																					pUser->GetGUID(), pUser->GetAuthIP());

	pUser->SetGMGrade( pRecvMsg->byGMGrade );
	MessageOut( eFULL_LOG, "GMUser PREPARE[Grade:%u][GUID:%u]", pRecvMsg->byGMGrade - eGM_GRADE_BASE, pUser->GetGUID() );

/*
	// ij¸¯ÅÍ À̸§ ¼¼ÆÃ.. ¾øÀ¸¸é ºó¹®ÀÚ¿­ ¼¼ÆÃ
	if( strcmp( pRecvMsg->szCharName, "" ) != 0 )
	{
		pUser->SetCharName( pRecvMsg->szCharName );
	}
	else
	{
*/
		pUser->SetCharName( "" );
//	}

	// PC¹æ ¼¼ÆÃ
	pUser->SetPCRoomID( pRecvMsg->dwPCRoomID );

	// ´ë±â ¸®½ºÆ®¿¡ Ãß°¡
	WaitingUserList::Instance()->AddUser( pRecvMsg->dwAuthUserID, pUser );

	//MessageOut(eCRITICAL_LOG,  "À¯Á® Á¢¼Ó ´ë±â.. ä³Î(%d) Guid(%d) IP(%s)", 
	//	pUser->GetChannelID(), pUser->GetGUID(), pUser->GetAuthIP() );

	// AgentServer¿¡ ÀÀ´ä
	MSG_AW_PREPARE_NEW_USER_ACK ackMsg;
	ackMsg.m_byCategory		= AW_CONNECTION;
	ackMsg.m_byProtocol		= AW_PREPARE_NEW_USER_ACK;
	ackMsg.m_dwKey			= pRecvMsg->m_dwKey;
	pAgentServer->Send( (BYTE*)&ackMsg, sizeof(ackMsg) );

	MessageOut( eFULL_LOG, "PREPARE_NEW_USER_SYN[Channel:%u][Guid:%u]", pUser->GetChannelID(), pUser->GetGUID() );
}

VOID Handler_AW::OnAW_USER_SET_CHARNAME_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_SET_CHARNAME_SYN *pRecvMsg = (MSG_AW_USER_SET_CHARNAME_SYN*)pMsg;

	User *pUser = UserManager::Instance()->FindUser( pRecvMsg->m_dwKey );//À¯Àú Á¤º¸¸¦ ã´Â´Ù.(ÀÔÀå½Ã¿¡ ÀúÀåÇÏ°Ô µÇ¸ç, À̶§±îÁö Äɸ¯ÅÍ Á¤º¸´Â ÀúÀåµÇ¾î ÀÖÁö ¾Ê´Ù.)

	if( !pUser )
	{
		//UserManager¿¡ ¾øÀ¸¸é ´ë±â ¸®½ºÆ®¿¡¼­ ã´Â´Ù.
        pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
		if( pUser )
		{
			pUser->SetCharGuid( pRecvMsg->dwCharGuid );
			pUser->SetCharName( pRecvMsg->szCharName );
			pUser->SetGuildGuid(pRecvMsg->m_GuildGuid);
			pUser->SetCharLevel( pRecvMsg->m_CharLevel);
            pUser->SetCharClass( pRecvMsg->m_CharClass );
#ifdef _NA_006642_20120416_COMMUNITY_INFO_BUG_MODIFY
            pUser->SetCharGender( pRecvMsg->gender );
#endif // _NA_006642_20120416_COMMUNITY_INFO_BUG_MODIFY
		}
		return;
	}
	else
	{
		// ÀÌÀü¿¡ Á¢¼ÓÇØ ÀÖ´ø ij¸¯ÅÍ ÀÖÀ» °æ¿ì ·Î±×¾Æ¿ô°ú ¸¶Âù°¡Áö·Î ó¸®ÇØ Áà¾ß ÇÑ´Ù(Ä£±¸ Á¤º¸³ª ºí·Ï Á¤º¸ µî)
		pUser->ProcessCharLogout();

		// ProcessCharLogout¿¡¼­ ÇØÁØ´Ù
//		// ³» Ä£±¸ Á¤º¸´Â ´õÀÌ»ó ÇÊ¿ä¾ø´Ù
//		UserManager::Instance()->RemoveFriend( pUser );
//
//		// äÆà ±ÝÁöÁßÀ̾úÀ» °æ¿ì äÆà ±ÝÁö ½Ã°£ ¾÷µ¥ÀÌÆ® ó¸®ÇÑ´Ù
//		if( pUser->IsChatBlocked() )
//		{
//			pUser->UpdateBlockTime();
//		}

		// UserManager¿¡¼­ ±âÁ¸ ij¸¯ÅÍ Á¤º¸ ¸®¼Â
		if( !UserManager::Instance()->UnSetCharGuid( pUser->GetCharGuid() ) )
		{
			User *pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
			if( pUser )
			{
				pUser->SetCharGuid( 0 );
				MessageOut( eFULL_LOG, "WaitingUserList - CharName Unset[%u]", pUser->GetGUID() );
			}
		}
		else
		{
			MessageOut( eFULL_LOG, "CharGuid Unset[%u]", pUser->GetGUID() );
		}
		if( !UserManager::Instance()->UnsetUserCharName( pRecvMsg->m_dwKey ) )
		{
			User *pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
			if( pUser )
			{
				pUser->SetCharName( "" );
				MessageOut( eFULL_LOG, "WaitingUserList - CharName Unset[%u]", pUser->GetGUID() );
			}
		}
		else
		{
			MessageOut( eFULL_LOG, "CharName Unset[%u]", pUser->GetGUID() );
		}

		// »õ·Î Á¤º¸ ÃʱâÈ­
		UserManager::Instance()->SetUserCharGuid( pRecvMsg->m_dwKey, pRecvMsg->dwCharGuid );
		UserManager::Instance()->SetUserCharName( pRecvMsg->m_dwKey, pRecvMsg->szCharName );
		UserManager::Instance()->SetUserCharLevel( pRecvMsg->m_dwKey, pRecvMsg->m_CharLevel );
        UserManager::Instance()->SetUserCharClass( pRecvMsg->m_dwKey, pRecvMsg->m_CharClass );
#ifdef _NA_006642_20120416_COMMUNITY_INFO_BUG_MODIFY
        UserManager::Instance()->SetUserCharGender( pRecvMsg->m_dwKey, pRecvMsg->gender );
#endif // _NA_006642_20120416_COMMUNITY_INFO_BUG_MODIFY

		// ±æµå ÀÖÀ¸¸é ¿©±â¼­ ¼¼ÆÃ
		if( pRecvMsg->m_GuildGuid )
		{
			pUser->SetGuildGuid( pRecvMsg->m_GuildGuid );
		}

		// Ä£±¸ ¸ñ·Ï ¿äû - ij¸¯ÅÍ ¼±ÅÃÀÌ µÈ °ÍÀ» Á¢¼ÓÀ¸·Î º»´Ù
		MSG_DW_FRIEND_GETLIST_SYN	sendMsg;

		sendMsg.m_CharGuid = pUser->GetCharGuid();

		ServerSession *pGameDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();
		if( !pGameDBProxy )
		{
			MessageOut( eCRITICAL_LOG, "Friend_NewList Error - No GameDBProxy");
			return;
		}
		pGameDBProxy->Send( (BYTE*)&sendMsg, sendMsg.GetSize() );

		// Chat Block È®ÀÎ ¿äûµµ Àü¼Û
		MSG_DW_GM_CHATBLOCKTIME_REQ	reqMsg;

		reqMsg.m_dwKey = pUser->GetCharGuid();

		pGameDBProxy->Send( (BYTE*)&reqMsg, sizeof(reqMsg) );

		MessageOut( eFULL_LOG, "[CharGuid:%u]ChatBlock Time Req", pUser->GetCharGuid() );

		MSG_DW_STATUS_INTERCEPTION_REQ msgREQ;
		msgREQ.m_dwKey		= pRecvMsg->m_dwKey;
		msgREQ.m_CharGuid	= pRecvMsg->dwCharGuid;
		pGameDBProxy->Send((BYTE*)&msgREQ, sizeof(msgREQ));   
	}
}

VOID Handler_AW::OnAW_USER_UNSET_CHARNAME_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_UNSET_CHARNAME_SYN *pRecvMsg = (MSG_AW_USER_UNSET_CHARNAME_SYN*)pMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_dwKey );

	if( pUser )
	{
		// ÀÌÀü¿¡ Á¢¼ÓÇØ ÀÖ´ø ij¸¯ÅÍ ÀÖÀ» °æ¿ì ·Î±×¾Æ¿ô°ú ¸¶Âù°¡Áö·Î ó¸®ÇØ Áà¾ß ÇÑ´Ù(Ä£±¸ Á¤º¸³ª ºí·Ï Á¤º¸ µî)
		pUser->ProcessCharLogout();
	}

	if( !UserManager::Instance()->UnSetCharGuid( pRecvMsg->m_dwKey ) )
	{
		User *pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
		if( pUser )
		{
			pUser->SetCharGuid( 0 );
			MessageOut( eFULL_LOG, "CharName Unset[%u]", pUser->GetGUID() );
		}
	}
	if( !UserManager::Instance()->UnsetUserCharName( pRecvMsg->m_dwKey ) )
	{
		User *pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
		if( pUser )
		{
			pUser->SetCharName( "" );
			MessageOut( eFULL_LOG, "WaitingUserList - CharName Unset[%u]", pUser->GetGUID() );
		}
	}

	MessageOut( eFULL_LOG, "CharName Unset Error - Unset Failed[%u]", pRecvMsg->m_dwKey );
}

VOID Handler_AW::OnAW_USER_ENTER_ZONE_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_ENTER_ZONE_SYN *pRecvMsg = (MSG_AW_USER_ENTER_ZONE_SYN*)pMsg;

	// ÇØ´ç À¯Á® Æ÷ÀÎÅÍ Ã£±â
	User *pUser = UserManager::Instance()->FindUser( pRecvMsg->m_dwKey );
	if( pUser )
	{
		Channel *pChannel = ChannelManager::Instance()->GetChannel( pUser->GetChannelID() );
		if( !pChannel )
		{
			MessageOut( eCRITICAL_LOG, "USER_ENTER_ZONE Error - [Guid:%u][ZT:%u][ZK:%u] Channel Not Exist!", pRecvMsg->m_dwKey, pRecvMsg->byZoneType, pRecvMsg->dwZoneKey );
			// ³Ê ÀÒ¾î¹ö·È´Ù! ´Ù½Ã ºÙ¾î¶ó!
//			pUser->Logout();
			return;
		}

		if( !pChannel->UserEnterZone( pUser, static_cast<eZONETYPE>(pRecvMsg->byZoneType), pRecvMsg->dwZoneKey, pRecvMsg->MapCode, (ChaosZoneType)pRecvMsg->chaoszone_type ) )
		{
#ifdef _DEBUG
			assert( !"invalid user status" );
#else
			MessageOut( eCRITICAL_LOG, "USER_ENTER_ZONE Error - No User Status[Guid:%u][Stat:%u]", pRecvMsg->m_dwKey, pRecvMsg->byZoneType );
			// ³Ê ÀÒ¾î¹ö·È´Ù! ´Ù½Ã ºÙ¾î¶ó!!!
//			pUser->Logout();
			return;
#endif
		}
	}
	else
	{
		// ÀÌ °æ¿ì´Â µ¿±âÈ­ ¿À·ù - óÀ½ µé¾î¿Ã ¶§´Â ¹Ýµå½Ã ¹ß»ýÇϸç, ó¸®ÇØ ÁÙ ÇÊ¿ä°¡ ¾ø´Ù
/*
		MessageOut( eFULL_LOG, "USER_ENTER_ZONE Error - User[%u] Á¢¼Ó ¾È ÇßÀ½(µ¿±âÈ­ ¿À·ù)", pRecvMsg->m_dwKey );

		pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
		if( pUser )
		{
#ifdef _DEBUG
			ASSERT( !pUser->GetZoneKey() && "LeaveZone ¾øÀÌ EnterZone!!!");	// sectorIndex°¡ 0 ¾Æ´Ï¸é LeaveZoneÀÌ Á¦´ë·Î ¾È µÆ´Ù´Â ¾ê±â
#else
			if( pUser->GetZoneKey() )
			{
				MessageOut( eCRITICAL_LOG, "USER_ENTER_ZONE Error - LeaveZone ¾øÀÌ EnterZone[Guid:%u][UserZT:%u][ZT:%u][ZK:%u]", 
											pRecvMsg->m_dwKey, pUser->GetStatus(), pRecvMsg->byZoneType, pRecvMsg->dwZoneKey );
				return;
			}
#endif
//			pUser->SeFtStatus( (eZONETYPE)pRecvMsg->byZoneType );
//			pUser->SetZoneKey( pRecvMsg->dwZoneKey );

			Channel *pChannel = ChannelManager::Instance()->GetChannel( pUser->GetChannelID() );
			if( !pChannel )
			{
				MessageOut( eCRITICAL_LOG, "USER_ENTER_ZONE_SYN Error - No User Channel %u(%u)", pUser->GetChannelID(), 
																								pUser->GetGUID() );
				return;
			}
		}
		else
		{
			MessageOut( eCRITICAL_LOG, "USER_ENTER_ZONE Error - No User[%u]", pRecvMsg->m_dwKey );
		}
*/
	}

    //ÃàÀûµÈ ÃÑ°æÇèÄ¡¾çÀÌ Á¸ÀçÇÏ¸é °ÔÀÓ¼­¹ö·Î º¸³»ÁØ´Ù.
}

VOID Handler_AW::OnAW_USER_LEAVE_ZONE_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_LEAVE_ZONE_SYN *pRecvMsg = (MSG_AW_USER_LEAVE_ZONE_SYN*)pMsg;
	
	// ÇØ´ç À¯Á® Æ÷ÀÎÅÍ Ã£±â
	User *pUser = UserManager::Instance()->FindUser( pRecvMsg->m_dwKey );
	if( pUser )
	{
		Channel *pChannel = ChannelManager::Instance()->GetChannel( pUser->GetChannelID() );
		if( !pChannel )
		{
			MessageOut( eCRITICAL_LOG, "USER_LEAVE_ZONE Error - [Guid:%u][ZT:%u][ZK:%u] Channel Not Exist!", pRecvMsg->m_dwKey, pRecvMsg->byZoneType, pRecvMsg->dwZoneKey );
			// ³Ê ÀÒ¾î¹ö·È´Ù! ´Ù½Ã ºÙ¾î¶ó!
//			pUser->Logout();
			return;
		}

		// º¹±¸³ª ·Î±×ÀÎ µ¿±âÈ­ ¸ÂÁö ¾ÊÀ» °æ¿ì _MAX »óÅ¿¡¼­ ÀÌ ÇÁ·ÎÅäÄÝÀÌ ¿Ã ¼ö ÀÖ´Ù. ´ëó ÇÊ¿ä.
		if( pUser->GetStatus() >= eZONETYPE_MAX )
		{
			MessageOut( eMIDDLE_LOG, "USER_LEAVE_ZONE Error - No User Status[Guid:%u][Stat:%u]", pRecvMsg->m_dwKey, pRecvMsg->byZoneType );
			// ³Ê ÀÒ¾î¹ö·È´Ù! ´Ù½Ã ºÙ¾î¶ó!!!
			pUser->Logout();
			return;
		}
		
		pChannel->UserLeavePrevZone( pUser );
	}
	else
	{
		pUser = WaitingUserList::Instance()->FindUserWithGuid( pRecvMsg->m_dwKey );
		if( pUser )
		{
			Channel *pChannel = ChannelManager::Instance()->GetChannel( pUser->GetChannelID() );
			if( !pChannel )
			{
				MessageOut( eCRITICAL_LOG, "[Guid:%u] Agent Leave[Channel:%u] Error - No Channel", pUser->GetGUID(), pUser->GetChannelID() );
				return;
			}

			MessageOut( eFULL_LOG, "[Guid:%u] Agent Leave Zone[Channel:%u]", pUser->GetGUID(), pUser->GetChannelID() );

			// ÆÄƼ key°¡ ÀÖÀ» °æ¿ì¶ó¸é(Á¢¼Ó º¹±¸ ÁßÀ̾úÀ» °æ¿ì) ÆÄƼ¿¡¼­ »© ÁØ´Ù
			if( pUser->GetParty() )
			{
				pChannel->WithdrawParty( pUser );
			}
//			pChannel->UserLeavePrevZone( pUser );
//			pUser->SetStatus( (eZONETYPE)pRecvMsg->byStatus );
//			pUser->SetZoneKey( pRecvMsg->dwZoneKey );
		}
	}

}

VOID Handler_AW::OnAW_USER_LOGOUT( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_LOGOUT *pRecvMsg = (MSG_AW_USER_LOGOUT*)pMsg;

	User *pUser = UserManager::Instance()->FindUser( pRecvMsg->m_dwKey );

	if( !pUser ) return;

	// À¯Á® Á¢¼Ó ²÷À½
	MessageOut(eCRITICAL_LOG, "AgentServer Disconnect User[%s][Guid:%u]", pUser->GetCharName().c_str(), pUser->GetGUID() );
	pUser->Logout();
}

//¿ùµå ¼­¹ö <---> Agent ¼­¹ö¿ÍÀÇ ¿¬°á¹®Á¦°¡ ÀÖÀ»½Ã¿¡ Ŭ¶óÀ̾ðÆ® È£ÃâÇÏ¿© Á¤º¸ º¹±¸
VOID Handler_AW::OnAW_USER_RESTORE_CMD( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_RESTORE_CMD* pRecvMsg = (MSG_AW_USER_RESTORE_CMD*)pMsg;

	User* pUser;
	DWORD dwChannelID = pAgentServer->GetChannelID();
	Channel* pChannel = ChannelManager::Instance()->GetChannel( dwChannelID );

	if( !pChannel )
	{
		MessageOut( eCRITICAL_LOG, "[C:%u] Agent Restore User[Guid:%u] Error - Invalid Channel!!", dwChannelID, pRecvMsg->dwUserGUID );
		return;
	}

	// ÇØ´ç À¯Á®°¡ ÀÌ¹Ì ÀÖ´Â °æ¿ì Á¢¼ÓÀ» ²÷´Â´Ù.
	pUser = UserManager::Instance()->FindUser( pRecvMsg->dwUserGUID );

	if( pUser )
	{
		MessageOut(eCRITICAL_LOG, "Duplicated guid! Disconnect Connected User[%s][Guid:%u][ZT:%u]", pUser->GetCharName().c_str(), 
																							pUser->GetGUID(), 
																							pRecvMsg->byZoneType );
		pUser->Logout();
//		return;
	}
	else
	{
		pUser = WaitingUserList::Instance()->FindUserWithAuthID( pRecvMsg->dwAuthUserID );

		if( pUser )
		{
			MessageOut(eCRITICAL_LOG, "WaitingUserList duplicated guid! Disconnect Connected User[%s][Guid:%u][ZT:%u]", pUser->GetCharName().c_str(), 
																								pUser->GetGUID(), 
																								pRecvMsg->byZoneType );
			pUser->Logout();
//			return;
		}
	}

	// ¾×Ƽºê À¯Á® ÇÒ´ç
	pUser = UserFactory::Instance()->Alloc( ACTIVE_USER );

	// À¯Á® Á¤º¸ ¼ÂÆÃ
	pUser->SetGUID( pRecvMsg->dwUserGUID );
	pUser->SetChannelID( dwChannelID );

	pUser->SetGMGrade( pRecvMsg->byGMGrade );
	MessageOut( eFULL_LOG, "GMUser PREPARE[Grade:%u][GUID:%u]", pRecvMsg->byGMGrade - eGM_GRADE_BASE, pUser->GetGUID() );

	// ÀÎÁõµÈ IP ¼ÂÆÃ
	pUser->SetAuthIP( pRecvMsg->pszClientIP );
	pUser->SetAuthID( pRecvMsg->dwAuthUserID );

	MessageOut(eFULL_LOG, "AW_USER_RESTORE_CMD[Channel:%u][Guid:%u][IP:%s]", pUser->GetChannelID(), 
																					pUser->GetGUID(), pUser->GetAuthIP());

	if( pRecvMsg->byZoneType != eZONETYPE_CHARSELECT )
	{
		// ij¸¯ÅÍ Á¤º¸ ¼¼ÆÃ
		pUser->SetCharGuid( pRecvMsg->CharGuid );
		pRecvMsg->tszCharName[MAX_CHARNAME_LENGTH] = '\0';
		pUser->SetCharName( pRecvMsg->tszCharName );
		pUser->SetStatus( (eZONETYPE)pRecvMsg->byZoneType );
		pUser->SetZoneKey( pRecvMsg->dwZoneKey );
		pUser->SetCharLevel(pRecvMsg->m_CharLevel);
        pUser->SetCharClass(pRecvMsg->m_CharClass);

		MessageOut( eCRITICAL_LOG, "[C:%u]AgentServer Restore User[Guid:%u][CharGuid:%u][ZT:%u][ZK:%u]", dwChannelID, 
																									pRecvMsg->dwUserGUID, 
																									pRecvMsg->CharGuid, 
																									pRecvMsg->byZoneType, 
																									pRecvMsg->dwZoneKey );

		// ±æµå ÀÖÀ¸¸é ¿©±â¼­ ¼¼Æà - ij¸¯ÅÍ ¼±ÅÃâ¿¡ ÀÖ´Ù¸é ¾îÂ÷ÇÇ CHARNAME_SELECTÇÒ ¶§ 󸮵ȴÙ
		if( pRecvMsg->m_GuildGuid )
		{
			pUser->SetGuildGuid( pRecvMsg->m_GuildGuid );

			WorldGuildManager::Instance()->RequestGuildRestore( pRecvMsg->m_GuildGuid, pUser->GetCharGuid() );
		}
		else
		{
			if( pUser->GetGuildGuid() )
			{
				MessageOut(eCRITICAL_LOG,
                           "USER_RESTORE Error - No Guild but have GuildGuid "
                           "[Guid:%u][CharGuid:%u][GuildGuid:%u]",
                           pUser->GetGUID(), pUser->GetCharGuid(), pUser->GetGuildGuid());
				pUser->SetGuildGuid( 0 );
			}
		}

        if( pUser->GetCharGuid() )
		{
			// Ä£±¸ ¸ñ·Ï ¿äû - ij¸¯ÅÍ ¼±Åà âÀÌ ¾Æ´Ñ °æ¿ì Á¢¼ÓµÈ À¯Àú·Î º»´Ù
			pUser->InitFriendListInit();	// ¿äûÇϱâ Àü¿¡ ÃʱâÈ­ÇØ ÁÖ´Â ½ë¾²!
            pUser->InitGroupInfo();

            ServerSession *pGameDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();
            if( !pGameDBProxy )
            {
                MessageOut( eCRITICAL_LOG, "Error Restore Friend_NewList & GroupList - No GameDBProxy");
                return;
            }

			MSG_DW_FRIEND_GETLIST_SYN	sendMsg;

			sendMsg.m_CharGuid = pUser->GetCharGuid();
			pGameDBProxy->Send( (BYTE*)&sendMsg, sendMsg.GetSize() );

            MSG_DW_GROUP_LIST_REQ msgList;//±×·ì ¸É¹ö ¸®½ºÆ® ¿äû ¸Þ¼¼Áö
            msgList.m_CharGUID = pUser->GetCharGuid();
            pGameDBProxy->Send( (BYTE*)&msgList, sizeof(msgList) );

			// Chat Block È®ÀÎ ¿äûµµ Àü¼Û
			MSG_DW_GM_CHATBLOCKTIME_REQ	reqMsg;

			reqMsg.m_dwKey = pUser->GetCharGuid();

			pGameDBProxy->Send( (BYTE*)&reqMsg, sizeof(reqMsg) );

			MessageOut( eFULL_LOG, "[CharGuid:%u]ChatBlock Time Req", pUser->GetCharGuid() );

			MSG_DW_STATUS_INTERCEPTION_REQ reqMSG;
			reqMSG.m_dwKey = pUser->GetGUID();
			reqMSG.m_CharGuid = pUser->GetCharGuid();
			pGameDBProxy->Send((BYTE*)&reqMSG, sizeof(reqMSG));
		}
	}
	else
	{
		MessageOut( eFULL_LOG, "[C:%u]AgentServer Restore User[Guid:%u]", dwChannelID, pRecvMsg->dwUserGUID );
	}

	// ÆÄƼ °á¼ºµÇ¾î ÀÖÀ¸¸é º¹±¸
	if( pRecvMsg->wPartyKey )
	{
		ChannelManager::Instance()->GetChannel( dwChannelID )->RestoreParty( pRecvMsg->wPartyKey, pUser );
	}

	// ID
	pUser->SetAccountID( pRecvMsg->ptszAccountID );

	// PC¹æ ¼¼ÆÃ
	pUser->SetPCRoomID( pRecvMsg->dwPCRoomID );

	// ´ë±â ¸®½ºÆ®¿¡ Ãß°¡
	WaitingUserList::Instance()->AddUser( pRecvMsg->dwAuthUserID, pUser );

	// AgentServer¿¡ ÀÀ´ä
	MSG_AW_PREPARE_NEW_USER_ACK ackMsg;
	ackMsg.m_byCategory		= AW_CONNECTION;
	ackMsg.m_byProtocol		= AW_PREPARE_NEW_USER_ACK;
	ackMsg.m_dwKey			= pRecvMsg->dwUserGUID;
	pAgentServer->Send( (BYTE*)&ackMsg, sizeof(ackMsg) );

	MessageOut( eFULL_LOG, "PREPARE_NEW_USER_SYN_CMD[Channel:%u][Guid:%u]", pUser->GetChannelID(), pUser->GetGUID() );
}


// ÆÄƼ °á¼º
VOID Handler_AW::OnAW_PARTY_MAKE_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_PARTY_MAKE_SYN* pRecvMsg = (MSG_AW_PARTY_MAKE_SYN*)pMsg;
	Channel *pChannel = ChannelManager::Instance()->GetChannel( pAgentServer->GetChannelID() );

	if( !pChannel )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_MAKE_SYN Error - [C:%u] Channel Not Exist!", pRecvMsg->m_dwKey );
		return;
	}

	pChannel->CreateParty( pRecvMsg->wPartyKey );
    
    MessageOut( eFULL_LOG, "Party Make Complete[C:%u][P:%u]", pChannel->GetChannelID(), pRecvMsg->wPartyKey );
}

// ÆÄƼ¿ø Ãß°¡
VOID Handler_AW::OnAW_PARTY_JOIN_MEMBER_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_PARTY_JOIN_MEMBER_SYN* pRecvMsg = (MSG_AW_PARTY_JOIN_MEMBER_SYN*)pMsg;

	Channel *pChannel = ChannelManager::Instance()->GetChannel( pAgentServer->GetChannelID() );

	if( !pChannel )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_JOIN_MEMBER_SYN Error - [C:%u] Channel Not Exist!", pRecvMsg->m_dwKey );
		return;
	}

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_CharGUID );

	if( !pUser )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_JOIN_MEMBER_SYN Error - [C:%u] User[CharGuid:%u] Not Exist!", pRecvMsg->m_dwKey, pRecvMsg->m_CharGUID );
		return;
	}

	if( !pChannel->JoinParty( pRecvMsg->wPartyKey, pUser ) )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_JOIN_MEMBER_SYN Error - [C:%u][P:%u][CharGuid:%u] Join Error!", pRecvMsg->m_dwKey, 
																										pRecvMsg->wPartyKey, 
																										pRecvMsg->m_CharGUID );
		return;
	}

    MessageOut( eFULL_LOG, "Party Join Complete[C:%u][P:%u][CharGuid:%u]", pRecvMsg->m_dwKey, 
        pRecvMsg->wPartyKey, 
        pRecvMsg->m_CharGUID );
}

// ÆÄƼ¿ø Å»Åð
VOID Handler_AW::OnAW_PARTY_WITHDRAW_MEMBER_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_PARTY_WITHDRAW_MEMBER_SYN* pRecvMsg = (MSG_AW_PARTY_WITHDRAW_MEMBER_SYN*)pMsg;

	Channel *pChannel = ChannelManager::Instance()->GetChannel( pAgentServer->GetChannelID() );

	if( !pChannel )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_WITHDRAW_MEMBER_SYN Error - [C:%u] Channel Not Exist!", pRecvMsg->m_dwKey );
		return;
	}

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_CharGUID );

	if( !pUser )
	{
		// ÀÌ °æ¿ì´Â Withdraw ÀÌÀü¿¡ ÀÌ¹Ì ÆÄƼ¿øÀÌ ¿ùµå¼­¹ö¿¡¼­ ²÷¾îÁø °æ¿ì - µû¶ó¼­ ¿¡·¯·Î º¼ ¼ö´Â ¾øÀ¸³ª MIDDLE_LOG Á¤µµ·Î °¨ÁöÇÏ¿© üũÇØ µÎÀÚ
		MessageOut( eMIDDLE_LOG, "PARTY_WITHDRAW_MEMBER_SYN Error - [C:%u] User[CharGuid:%u] Not Exist!", pRecvMsg->m_dwKey, pRecvMsg->m_CharGUID );
		return;
	}

	if( !pChannel->WithdrawParty( pUser ) )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_WITHDRAW_MEMBER_SYN Error - [C:%u][P:%u][CharGuid:%u] Withdraw Error!", pRecvMsg->m_dwKey, 
																										pRecvMsg->wPartyKey, 
																										pRecvMsg->m_CharGUID );
		return;
	}

    MessageOut( eFULL_LOG, "Party Withdraw Complete[C:%u][P:%u][CharGuid:%u]", pRecvMsg->m_dwKey, 
        pRecvMsg->wPartyKey, 
        pRecvMsg->m_CharGUID );
}

// ÆÄƼ ÇØü
VOID Handler_AW::OnAW_PARTY_DESTROY_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_PARTY_DESTROY_SYN* pRecvMsg = (MSG_AW_PARTY_DESTROY_SYN*)pMsg;
	Channel *pChannel = ChannelManager::Instance()->GetChannel( pAgentServer->GetChannelID() );

	if( !pChannel )
	{
		MessageOut( eCRITICAL_LOG, "PARTY_DESTROY_SYN Error - [C:%u] Channel Not Exist!", pRecvMsg->m_dwKey );
		return;
	}

	pChannel->DestroyParty( pRecvMsg->wPartyKey );
	

    MessageOut( eFULL_LOG, "Party Destroy Complete[C:%u][P:%u]", pChannel->GetChannelID(), pRecvMsg->wPartyKey );
}

// GM ±Ó¸» ÄÔ/²û
VOID Handler_AW::OnAW_GM_WHISPER_SET_CMD(  AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_GM_WHISPER_SET_CMD *pRecvMsg = (MSG_AW_GM_WHISPER_SET_CMD*)pMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_dwKey );

	if(!pUser)
	{
		MessageOut(eCRITICAL_LOG,  "GM Whisper Set Failed(pUser == NULL)");
		return;
	}

	// ÀÌ À¯ÀúÀÇ ±Ó¸» ÄÔ/²û »óÅ ¼¼ÆÃ
	pUser->SetWhisper(pRecvMsg->m_bOn);

	// ¼º°øÇßÀ½À» ¾Ë¸°´Ù
	MSG_CW_GM_WHISPER_SET_ACK	resMsg;

	resMsg.m_bOn = pRecvMsg->m_bOn;

	pUser->SendPacket( (BYTE*)&resMsg, sizeof(MSG_CW_GM_WHISPER_SET_ACK) );

	MessageOut(eCRITICAL_LOG,  "(%s) GM Whisper Set(%d)", pUser->GetCharName().c_str(), pRecvMsg->m_bOn);
}

// äÆñÝÁö/Çã¿ë
VOID Handler_AW::OnAW_GM_USERCHAT_BLOCK_CMD(  AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	// ¿î¿µÆÀÀÇ Á¤È®ÇÑ ¿ä±¸»çÇ×À» ¸ô¶ó¼­ ÀÏ´Ü º¸·ù
	MSG_AW_GM_USERCHAT_BLOCK_CMD* pRecvMsg = (MSG_AW_GM_USERCHAT_BLOCK_CMD*)pMsg;

	Channel *pChannel = ChannelManager::Instance()->GetChannel(pAgentServer->GetChannelID());
	if(!pChannel)
	{
		MessageOut(eCRITICAL_LOG, "AW_GM_USERCHAT_BLOCK_CMD Error - [C:%u] Channel Not Exist!", pRecvMsg->m_dwKey);
		return;
	}

	// ¿äû À¯Àú ã¾Æ¼­ GMÀÎÁö °Ë»çÇÏ°í, ´ë»ó À¯ÀúÀÇ »óÅ¿¡ µû¶ó BlockÇÑ´Ù
	User *pGM = UserManager::Instance()->FindUserByCharGuid(pRecvMsg->m_dwKey);
	if(!pGM)
	{
		MessageOut(eCRITICAL_LOG, "UserChat Block Error - GMUser Not Connected[GM:%u]", pRecvMsg->m_dwKey);
		return;
	}

	User *pBlockUser = UserManager::Instance()->FindUserByCharGuid(pRecvMsg->m_CharGuid);
	// Á¢¼Ó ÁßÀÌÁö ¾ÊÀº À¯Àú´Â ºí¶ô ¸ÔÀÏ ¼ö ¾ø´Ù!!
	// ¸¸ÀÏ ±× ±â´ÉÀ» Áö¿øÇÏ·Á¸é ÀÌ °æ¿ì°¡ »ý±æ ¶§¸¶´Ù DB Äõ¸®¸¦ ÅëÇØ ÇØ´ç À¯Àú°¡ Á¸ÀçÇÏ´ÂÁö °Ë»çÇØ¾ß ÇϹǷÎ
	// ±× ±â´ÉÀº ÇâÈÄ WOPS¿¡¼­³ª Áö¿øÇØ¾ß ÇÒ °ÍÀÌ´Ù
	if(!pBlockUser)
	{
		MSG_CW_GM_USERCHAT_BLOCK_NAK nakMsg;
		nakMsg.m_dwKey = pRecvMsg->m_dwKey;
		nakMsg.m_wErrorCode = RC::RC_CHAT_NOCHAR;
		MessageOut( eCRITICAL_LOG, "UserChat Block Error - BlockUser Not Connected[%u]", pRecvMsg->m_CharGuid );
		return;
	}

	// ±ÝÁöÀÏ ¶§ ó¸®
	if(TRUE == pRecvMsg->m_bBlock)
	{
		// ÀÌ¹Ì ±ÝÁö »óÅÂÀε¥ ¶Ç ³¯¾Æ¿À¸é ¿À·ù
		if(pBlockUser->IsChatBlocked())
		{
			MSG_CW_GM_USERCHAT_BLOCK_NAK nakMsg;

			nakMsg.m_dwKey = pRecvMsg->m_dwKey;
			nakMsg.m_wErrorCode = RC::RC_CHAT_BLOCKED;
			MessageOut(eCRITICAL_LOG, "UserChat Block Error - Already Blocked User[%u]", pRecvMsg->m_CharGuid);
			return;
		}

		// ±ÝÁö Ãß°¡
		MSG_DW_GM_CHATBLOCK_SYN	sendMsg;

        //__NA_000313_20070223_REALTIME_CHAT_BLOCK
		sendMsg.m_dwKey = pGM->GetCharGuid();
		sendMsg.m_CharGuid = pBlockUser->GetCharGuid();
		sendMsg.m_dwBlockTIme = pRecvMsg->m_dwBlockTime;
		_tcsncpy( sendMsg.m_ptszGMAccountID, pGM->GetCharName().c_str(), MAX_CHARNAME_LENGTH );

		ServerSession *pGameDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();
		if(!pGameDBProxy)
		{
			MessageOut(eCRITICAL_LOG, "DW_CHATBLOCK Error - No GameDBProxy");
			return;
		}
		pGameDBProxy->Send((BYTE*)&sendMsg, sizeof(sendMsg));

		// ½ÇÁ¦ ±ÝÁö ¼¼ÆÃ
//		pBlockUser->SetChatBlock( pRecvMsg->m_dwBlockTime );

		MessageOut(eFULL_LOG, "ChatBlock Set - Block[%u][CharGuid:%u][Time:%u]", pBlockUser->GetGUID(), pBlockUser->GetCharGuid(), 
																					pRecvMsg->m_dwBlockTime);
	}
	else	// Çã¿ëÀÏ ¶§ ó¸®
	{
		// ÀÌ¹Ì Çã¿ë »óÅÂ¸é ¿À·ù
		if(!pBlockUser->IsChatBlocked())
		{
			MSG_CW_GM_USERCHAT_BLOCK_NAK nakMsg;

			nakMsg.m_dwKey = pRecvMsg->m_dwKey;
			nakMsg.m_wErrorCode = RC::RC_CHAT_ALLOWED;
			MessageOut(eCRITICAL_LOG, "UserChat Block Error - Not Blocked User[%u]", pRecvMsg->m_CharGuid);
			return;
		}

		// Çã¿ëÇß´Ù°í ¾Ë·ÁÁØ´Ù
		MSG_DW_GM_CHATALLOW_SYN	sendMsg;

		sendMsg.m_dwKey = pGM->GetCharGuid();
		sendMsg.m_CharGuid = pBlockUser->GetCharGuid();
		_tcsncpy( sendMsg.m_ptszGMAccountID, pGM->GetCharName().c_str(), MAX_CHARNAME_LENGTH );

		ServerSession *pGameDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();
		if(!pGameDBProxy)
		{
			MessageOut(eCRITICAL_LOG, "DW_CHATALLOW Error - No GameDBProxy");
			return;
		}
		pGameDBProxy->Send((BYTE*)&sendMsg, sizeof(sendMsg));

		MessageOut(eFULL_LOG, "ChatBlock Set - Allow[%u][CharGuid:%u]", pBlockUser->GetGUID(), pBlockUser->GetCharGuid());
	}
}

// À¯Àú ·¹º§¾÷ ó¸®
VOID Handler_AW::OnAW_USER_LEVELUP_CMD( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_USER_LEVELUP_CMD* pRecvMsg = (MSG_AW_USER_LEVELUP_CMD*)pMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_CharGuid );

	if( !pUser )
	{
		MessageOut( eCRITICAL_LOG, "AW_USER_LEVELUP_CMD Error - No Levelup User[CharGuid:%u]", pRecvMsg->m_CharGuid );
		return;
	}
    //·¹º§ ¾÷, added by _KR_0_20091021_FIRENDINVITATION_EXTEND
    WFriendInvitationController::Instance()->OnCharacterLevelUp(pAgentServer, pMsg, wSize);	
    // Ä£±¸ ¾Ë¸²
	MSG_CW_FRIEND_LEVELUP_BRD	friendMsg;
	friendMsg.m_Level = pRecvMsg->m_Level;
	memset( friendMsg.m_ptszCharName, 0, sizeof(TCHAR)*(MAX_CHARNAME_LENGTH+1) );
	_tcsncpy( friendMsg.m_ptszCharName, pUser->GetCharName().c_str(), MAX_CHARNAME_LENGTH );
	pUser->SendOnlineFriendAll( (BYTE*)&friendMsg, sizeof(friendMsg) );

	// ¸®º¥Áö ÆÐŶÀ¸·Î Ä«Å×°í¸®/ÇÁ·ÎÅäÄݸ¸ ¹Ù²ã¼­ Çѹø ´õ º¸³½´Ù
	friendMsg.m_byCategory = CW_REVENGE;
	friendMsg.m_byProtocol = CW_REVENGE_LEVELUP_BRD;
	pUser->SendOnlineRevengeAll( (BYTE*)&friendMsg, sizeof(friendMsg) );

	MessageOut( eFULL_LOG, "FriendLevelup Msg Send[CharGuid:%u]", pRecvMsg->m_CharGuid );
	pUser->SetOnlineLevel( pRecvMsg->m_Level );
	pUser->SetCharLevel(pRecvMsg->m_Level);

    //±×·ì ¸â¹öµé¿¡°Ôµµ ·¹º§¾÷À» ¾Ë¸°´Ù.
    GroupManager::Instance()->SendAroundMember( pUser, GroupManager::MEMBER_LEVELUP );
}

//////////////////////////////////////
// ¸®º¥Áö(³ª»ÛÄ£±¸) °ü·Ã ÆÐŶ Çڵ鷯

VOID Handler_AW::OnAW_CHAO_REQUEST_REVENGEINFO_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_CHAO_REQUEST_REVENGEINFO_SYN* pRecvMsg = (MSG_AW_CHAO_REQUEST_REVENGEINFO_SYN*)pMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_dwCharGuid );
	if( !pUser )
	{
		ServerSession* pAgentServer = ServerSessionManager::Instance()->FindAgentServer(WorldServer::Instance()->GetChannelID());
		if(pAgentServer)
		{
            // TODO(WAVERIX) (090623) (NOTE) Àç°ËÁõ ¼öÇàÇÏÀÚ.
			MSG_AW_ABUSING_USER_VERIFY_QUERY_CMD msg;
			msg.m_dwKey = pRecvMsg->m_dwKey;
			msg.m_CharGuid = pRecvMsg->m_dwCharGuid;
			msg.m_eAbuseSubType = eABUSE_SUB_LOGIC_VIOLATION_USER_NONE_WORLDSVR;
			pAgentServer->Send((BYTE*)&msg, sizeof(msg));
		}
		return;
	}

	// ¸®º¥Áö Á¤º¸ Àü¼ÛÇÑ´Ù
	MSG_AW_CHAO_REQUEST_REVENGEINFO_ACK ackMsg;
	ackMsg.m_dwKey = pRecvMsg->m_dwKey;
	ackMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
	ackMsg.m_byRevengePoint = pUser->GetRevengePoint();
	ackMsg.m_byRevengeStatNum = pUser->GetRevengeNum();

	if( ackMsg.m_byRevengeStatNum > 0 )
	{
		STRUCT_REVENGE_INFO* pRevengeInfo = pUser->GetFirstRevenge();

		memcpy( ackMsg.m_sRevengeUserInfo, pRevengeInfo, sizeof(STRUCT_REVENGE_INFO) );

		int i=1;
		while( pRevengeInfo = pUser->GetNextRevenge() )
		{
			memcpy( &ackMsg.m_sRevengeUserInfo[i], pRevengeInfo, sizeof(STRUCT_REVENGE_INFO) );
			i++;
		}
	}

	pAgentServer->Send( (BYTE*)&ackMsg, ackMsg.GetSize() );

	MessageOut( eFULL_LOG, "REQUEST_REVENGEINFO_ACK Send[CharGuid:%u][RevengeNum:%u]", pRecvMsg->m_dwCharGuid, ackMsg.m_byRevengeStatNum );
}

VOID Handler_AW::OnAW_CHAO_REMOVE_REVENGE_CHAR_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	// PK¿¡ ¼º°øÇÑ °æ¿ì
	MSG_AW_CHAO_REMOVE_REVENGE_CHAR_SYN* pRecvMsg = (MSG_AW_CHAO_REMOVE_REVENGE_CHAR_SYN*)pMsg;
	MSG_AW_CHAO_REMOVE_REVENGE_CHAR_NAK nakMsg;

	// ¸®º¥Áö °¡´ÉÇÑ ´ë»óÀÎÁö °Ë»ç
	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_dwCharGuid );

	if( !pUser )
	{
		nakMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
		nakMsg.m_byErrorCode = RC::RC_REVENGE_NO_CHAR;

		pAgentServer->Send( (BYTE*)&nakMsg, sizeof(nakMsg) );

		MessageOut( eCRITICAL_LOG, "AW_CHAO_REMOVE_REVENGE Error - Not Connected User[CharGuid:%u]", pRecvMsg->m_dwCharGuid );
		return;
	}

	STRUCT_REVENGE_INFO *pRevengeInfo = pUser->FindRevenge( pRecvMsg->m_dwRevengeCharGuid );

	if( !pRevengeInfo )
	{
		nakMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
		nakMsg.m_byErrorCode = RC::RC_REVENGE_INVALID_CHAR;

		MessageOut( eCRITICAL_LOG, "AW_CHAO_REMOVE_REVENGE Error - Invalid Revenge Target[CharGuid:%u][Target:%u]", 
																					pRecvMsg->m_dwCharGuid, pRecvMsg->m_dwRevengeCharGuid );
		return;
	}

	// È®½ÇÇÑ Á¤º¸ÀÏ °æ¿ì DB¿¡ »èÁ¦ ¿äû
	ServerSession *pDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();

	if( !pDBProxy )
	{
		nakMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
		nakMsg.m_byErrorCode = RC::RC_REVENGE_FAILED;

		MessageOut( eCRITICAL_LOG, "AW_CHAO_REMOVE_REVENGE Error - No DBProxy!!![CharGuid:%u]", pRecvMsg->m_dwCharGuid );
		return;
	}

	MSG_DW_CHAO_PK_REVENGE_CHAR_SYN	sendMsg;

	sendMsg.m_dwKey = pAgentServer->GetChannelID();
	sendMsg.m_CharGuidFrom = pRecvMsg->m_dwCharGuid;
	sendMsg.m_RevengeGuidTo = pRecvMsg->m_dwRevengeCharGuid;

	pDBProxy->Send( (BYTE*)&sendMsg, sizeof(sendMsg) );
	pUser->SetFriendTransaction( TRUE );

	MessageOut( eFULL_LOG, "CHAO_REMOVE_REVENGE Send[CharGuid:%u][Target:%u]", sendMsg.m_CharGuidFrom, sendMsg.m_RevengeGuidTo );
}

VOID Handler_AW::OnAW_CHAO_ADD_REVENGE_CHAR_SYN( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
	MSG_AW_CHAO_ADD_REVENGE_CHAR_SYN* pRecvMsg = (MSG_AW_CHAO_ADD_REVENGE_CHAR_SYN*)pMsg;
	MSG_AW_CHAO_ADD_REVENGE_CHAR_NAK nakMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid( pRecvMsg->m_dwCharGuid );

	if( !pUser )
	{
		nakMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
		nakMsg.m_byErrorCode = RC::RC_REVENGE_NO_CHAR;

		pAgentServer->Send( (BYTE*)&nakMsg, sizeof(nakMsg) );
		MessageOut( eCRITICAL_LOG, "AW_CHAO_ADD_REVENGE_CHAR_SYN Error - Not Connected User[%u]", pRecvMsg->m_dwCharGuid );
		return;
	}

	// ¸®º¥Áö Æ÷ÀÎÆ®°¡ ³²¾Æ ÀÖ´ÂÁö È®ÀÎ
	if( !pUser->GetRevengePoint() )
	{
		nakMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
		nakMsg.m_byErrorCode = RC::RC_REVENGE_NO_POINT;

		pAgentServer->Send( (BYTE*)&nakMsg, sizeof(nakMsg) );
		MessageOut( eCRITICAL_LOG, "AW_CHAO_ADD_REVENGE_CHAR_SYN Error - No Point[%u]", pRecvMsg->m_dwCharGuid );
		return;
	}

	// ¹Ù·Î DB Àü¼Û~
	MSG_DW_CHAO_ADD_REVENGE_CHAR_SYN sendMsg;

	sendMsg.m_dwKey = pAgentServer->GetChannelID();
	sendMsg.m_CharGuidFrom = pRecvMsg->m_dwCharGuid;
	memset( sendMsg.m_ptszCharNameTo, 0, sizeof(TCHAR)*(MAX_CHARNAME_LENGTH+1) );
	_tcsncpy( sendMsg.m_ptszCharNameTo, pRecvMsg->m_ptszRevengeName, MAX_CHARNAME_LENGTH );

	ServerSession *pDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();

	if( !pDBProxy )
	{
		MessageOut( eCRITICAL_LOG, "AW_CHAO_ADD_REVENGE Error - No DBProxy!!!" );

		MSG_AW_CHAO_ADD_REVENGE_CHAR_NAK nakMsg;

		nakMsg.m_dwCharGuid = pRecvMsg->m_dwCharGuid;
		nakMsg.m_byErrorCode = RC::RC_REVENGE_FAILED;
		return;
	}

	pDBProxy->Send( (BYTE*)&sendMsg, sizeof(sendMsg) );
	pUser->SetFriendTransaction( TRUE );

	MessageOut( eFULL_LOG, "AW_CHAO_ADD_REVENGE_CHAR_SYN send to DBProxy[CharGuid:%u][Name:%s]", sendMsg.m_CharGuidFrom, sendMsg.m_ptszCharNameTo );
}


// ½ºÆä¼È ¾ÆÀÌÅÛ ¼ÒÀ¯ º¯°æ
VOID Handler_AW::OnAW_ITEM_CHANGE_SPECIAL_ITEM_OWN_CMD(AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize)
{
	MSG_AW_ITEM_CHANGE_SPECIAL_ITEM_OWN_CMD *pRecvMsg = (MSG_AW_ITEM_CHANGE_SPECIAL_ITEM_OWN_CMD*)pMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid(pRecvMsg->m_dwCharGuid);
	if(!pUser) return;

    for(int cnt = 0; cnt < pRecvMsg->m_Count; cnt++)
	{			
		if(pRecvMsg->m_ItemInfo[cnt].m_Apply)
		{
			pUser->GetItemOwnFlag().IncItemInfo( (eITEMTYPE)pRecvMsg->m_ItemInfo[cnt].m_ItemType, pRecvMsg->m_ItemInfo[cnt].m_Count );
			MessageOut( eFULL_LOG, "SPECIAL ITEM INC_[CHARGUID:%u][ITEMTYPE:%d]",
                pUser->GetCharGuid(), (eITEMTYPE)pRecvMsg->m_ItemInfo[cnt].m_ItemType);
		}
		else
		{
			pUser->GetItemOwnFlag().DecItemInfo( (eITEMTYPE)pRecvMsg->m_ItemInfo[cnt].m_ItemType, pRecvMsg->m_ItemInfo[cnt].m_Count );
			MessageOut( eFULL_LOG, "SPECIAL ITEM DEC_[CHARGUID:%u][ITEMTYPE:%d]",
				pUser->GetCharGuid(), (eITEMTYPE)pRecvMsg->m_ItemInfo[cnt].m_ItemType);
		}
	}
}

VOID Handler_AW::OnAW_ITEM_SPECIAL_ITEM_CLEAR_CMD(AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize)
{	
	MSG_AW_ITEM_SPECIAL_ITEM_CLEAR_CMD *pRecvMsg = (MSG_AW_ITEM_SPECIAL_ITEM_CLEAR_CMD*)pMsg;

	User *pUser = UserManager::Instance()->FindUserByCharGuid(pRecvMsg->m_dwCharGuid);
	if(!pUser) return;

	pUser->GetItemOwnFlag().Init();
}

VOID Handler_AW::OnAW_ITEM_USE_DECREE_ITEM_ACK(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
	//¿ùµå ¿ÜÄ¡±â
    MSG_AW_ITEM_USE_DECREE_ITEM_ACK* pRecvMsg = (MSG_AW_ITEM_USE_DECREE_ITEM_ACK*)pMsg;
	User* pUser = UserManager::Instance()->FindUser(pRecvMsg->m_dwKey);
	if(!pUser)	return;

	MSG_CW_CHAT_SHOUT_BRD msgBRD;
	do
	{
		// TODO(WAVERIX) (NOTE) m_tszTmpDecreeMsgÀÇ ¹öÆÛÅ©±â´Â 256ÀÔ´Ï´Ù¸¸...? -.-;
		BYTE byMsgLength = _tcslen(pUser->GetTmpDecreeMsg());
		util::cSTRING_REF strMsgRD(pUser->GetTmpDecreeMsg(), sizeof(byMsgLength));

		util::cSTRING_REF_RW strNameRW4BRD( msgBRD.m_szCharName, sizeof(msgBRD.m_szCharName) );
		strNameRW4BRD.CopyFromString( pUser->GetCharName().c_str() );
		strNameRW4BRD.MakeSafeString();

		util::cSTRING_REF_RW strMsgRW4BRD( msgBRD.m_pszChatMsg, sizeof(msgBRD.m_pszChatMsg) );
		strMsgRW4BRD.CopyFromString(pUser->GetTmpDecreeMsg());
		strMsgRW4BRD.MakeSafeString();

		msgBRD.m_byMsgLength = strMsgRW4BRD.GetSTRING_LENGTH()+1;
	} while(0);

	msgBRD.m_byMessageType = msgBRD.DECREE_SHOUT;

	UserManager::Instance()->SendToAll((BYTE*)&msgBRD, msgBRD.GetSize());
}

VOID Handler_AW::OnAW_ITEM_USE_DECREE_ITEM_NAK(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
	MSG_AW_ITEM_USE_DECREE_ITEM_NAK* pRecvMsg = (MSG_AW_ITEM_USE_DECREE_ITEM_NAK*)pMsg;

	User* pUser = UserManager::Instance()->FindUser(pRecvMsg->m_dwKey);
	if(!pUser)	return;

	MSG_CW_CHAT_SHOUT_NAK msgNAK;
	msgNAK.m_wErrorCode = RC::RC_CHAT_NOT_DECREE_ITEM;
	pUser->SendPacket((BYTE*)&msgNAK, sizeof(msgNAK) );
}

#ifdef _NA_20101011_HEIM_LOTTO_CASH_TICKET
// ÇÏÀÓÇà¿î ij½Ã ÀÀ¸ð±Ç »ç¿ë ¿äû
VOID Handler_AW::OnAW_ITEM_USE_HEIM_LOTTO_TICKET_SYN(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    const MSG_AW_ITEM_USE_HEIM_LOTTO_TICKET_SYN* msg = \
        static_cast<const MSG_AW_ITEM_USE_HEIM_LOTTO_TICKET_SYN*>(pMsg);

    // ÇØ´ç ij¸¯ÅÍ°¡ ÁøÇà ÁßÀÎ °ÇÀÌ ÀÖ´ÂÁö °Ë»çÇÑ´Ù.
    const TicketActivationXactions& xactions = Lotto::GetInstance().GetTicketActivationXactions();
    if (xactions.Find(msg->char_guid) != NULL)
    {
        // ÀÌ¹Ì ÁøÇà ÁßÀÎ °ÇÀÌ ÀÖ´Ù¸é ¿À·ù ¸®ÅÏ
        MSG_AW_ITEM_USE_HEIM_LOTTO_TICKET_ACK ack;
        ack.result_code = static_cast<WORD>(RC::RC_ITEM_INVALIDSTATE);
        ack.char_guid   = msg->char_guid;
        ack.index       = msg->index;
        ack.pos         = msg->pos;
        pAgentServer->Send((BYTE*)&ack, (WORD)sizeof(ack));
        return;
    }

    Lotto::GetInstance().OnTicketActivation(pMsg);
}
#endif // _NA_20101011_HEIM_LOTTO_CASH_TICKET

VOID Handler_AW::OnAW_USER_STATUS_INTERCEPTION_SYN(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
	MSG_AW_USER_STATUS_INTERCEPTION_SYN* pRecvMsg = (MSG_AW_USER_STATUS_INTERCEPTION_SYN*)pMsg;

	User* pUser = UserManager::Instance()->FindUser(pRecvMsg->m_dwKey);
	if(!pUser)	return;

	pUser->SetInterceptionOption(pRecvMsg->m_byInterceptionCode, pRecvMsg->m_bFlag);
}

VOID Handler_AW::OnAW_GM_NOTICE_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{	
	MSG_AW_GM_NOTICE_CMD* pRecvMsg = (MSG_AW_GM_NOTICE_CMD *)pMsg;

	User *pUser = UserManager::Instance()->FindUser(pRecvMsg->m_dwKey);
	if(!pUser)	return;

	m_GMCmdManager.ProcessNoticeType(pUser, pRecvMsg->m_eType, pRecvMsg->m_tszNoticeMsg);
}

VOID Handler_AW::OnAW_GM_LOTTO_NUM_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    MSG_AW_GM_LOTTO_NUM_CMD* pRecvMsg = (MSG_AW_GM_LOTTO_NUM_CMD*)pMsg;

    User* pUser = UserManager::Instance()->FindUser(pRecvMsg->dwUserKey);
    if (pUser == NULL) { return; }

    MSG_CW_LOTTO_FINISH_BRD resp;

    resp.wDrawNum = (WORD)Lotto::GetInstance().GetCurrentDrawNum();
    Lotto::GetInstance().GetCurrentWinningNum(resp.bWinningNum);

    pUser->SendPacket((BYTE*)&resp, (WORD)sizeof(resp));
}

VOID Handler_AW::OnAW_GM_LOTTO_SETTLE_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    MSG_AW_GM_LOTTO_SETTLE_CMD* pRecvMsg = (MSG_AW_GM_LOTTO_SETTLE_CMD*)pMsg;

    User* pUser = UserManager::Instance()->FindUser(pRecvMsg->dwUserKey);
    if (pUser == NULL) { return; }

    Lotto::GetInstance().ForceRollOver();
}

VOID Handler_AW::OnAW_GM_LOTTO_FUND_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    MSG_AW_GM_LOTTO_FUND_CMD* pRecvMsg = (MSG_AW_GM_LOTTO_FUND_CMD*)pMsg;

    User* pUser = UserManager::Instance()->FindUser(pRecvMsg->user_key);
    if (pUser == NULL) { return; }

    Lotto::GetInstance().OnTotalAccumChange(pRecvMsg->amount_delta);
}

VOID Handler_AW::OnAW_STATUS_GROUP_START_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    const MSG_AW_STATUS_GROUP_START_CMD* pRecvMsg = 
        static_cast<MSG_AW_STATUS_GROUP_START_CMD*>(pMsg);

    MSG_DW_GROUP_LIST_REQ msgList;//±×·ì ¸É¹ö ¸®½ºÆ® ¿äû ¸Þ¼¼Áö
    msgList.m_CharGUID = pRecvMsg->m_CharGuid;

    ServerSession *pGameDBProxy = ServerSessionManager::Instance()->GetGameDBProxy();
    
    if (pGameDBProxy == NULL)
        return;

    pGameDBProxy->Send((BYTE*)&msgList, sizeof(msgList));
}

VOID Handler_AW::OnAW_OPERATION_ROOM_CTRL_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    using namespace nsSSQ;
	const MSG_AW_OPERATION_ROOM_CTRL_CMD* pRecvMsg = static_cast<const MSG_AW_OPERATION_ROOM_CTRL_CMD*>(pMsg);

	const WAR_MSG_HDR* IN pStream = pRecvMsg->m_Header;
	const WAR_MSG_HDR IN header = *pStream;

	WAR_TAG_P pIt	= (WAR_TAG_P)(pStream+1);
	WAR_TAG_P pEnd	= pIt + header.size;
	for( WORD size=0 ; pIt<pEnd ; pIt+=size )
	{
		size	= 10000;	// ¹Ì ¼³Á¤¿¡ ´ëÇÑ ½ºÅµ ¼³Á¤

		switch( pIt->_TAG )
		{
		case SSQ_S2S_SET_CHAT_BLOCK_ZONE:
			{
				RECV_PATTERNCODE_FOR_SSQ( SSQ_S2S_SET_CHAT_BLOCK_ZONE );

				ChannelManager* const pChannelManager = ChannelManager::Instance();
				const DWORD channel_ID = pAgentServer->GetChannelID();
				Channel* const pChannel = pChannelManager->GetChannel( channel_ID );
				if( !pChannel )
					break;

				ChatZone* const pChatZone = pChannel->FindZone( rMsg.ZoneKey );
				if( !pChatZone )
					break;

                // (WAVERIX) (090220) (BUG-FIX) Ÿ¶ôÇÑ »ç¿ø ÀüÅõ Á÷Àü, ¿ùµå¼­¹öÀÇ °¢Á¾ ±â´ÉÀÌ µ¿
                //ÀÛµÇÁö ¾Êµµ·Ï ÇÏ´Â ±â´ÉÀÌ ´ç½Ã Çöö¾¾¶û ÇùÀǽà Âø¿À·Î ÀÎÇØ °Å²Ù·Î ¼³Á¤ÇØ
                //¿ùµå¼­¹ö °ü·ÃÇؼ­ µ¿ÀÛÇÏ´Â ±â´ÉÀÌ Çã¿ëµÇ´Â ¹®Á¦ ¼öÁ¤.
				pChatZone->SetBlockZone(rMsg.Enabled == FALSE);
			}
			break;
		default:
			{
				SUNLOG( eCRITICAL_LOG, "Can't Readable SSQ Msg Format %2u", pIt->_TAG );
			}
			break;
		}
	}
}

// __KR_001355_20090608_EXP_ACQUISITION_NOTIFICATION
VOID Handler_AW::OnAW_STATUS_GROUP_EXP_ACQUISITION_CMD(AgentServerSession* agent_server, MSG_BASE* msg, WORD size)
{
    const MSG_AW_STATUS_GROUP_EXP_ACQUISITION_CMD* recv_msg = 
        static_cast<MSG_AW_STATUS_GROUP_EXP_ACQUISITION_CMD*>(msg);

    User* user = UserManager::Instance()->FindUserByCharGuid(recv_msg->m_CharGuid);
    if (user == NULL)
    {
        return;
    }

    user->SetCurBonusEXP(recv_msg->m_Amount);

#ifdef _NA_20101026_CHANGE_GROUP_BONUS_APPLY_WAY 
    if (GroupManager::Instance()->GetGroupLowMember(user) == GROUP_HAVE_ONLINE_LOW)
    {
        GroupManager::Instance()->SendAroundMember(user, GroupManager::GET_EXP);
    }
#else
    if (GroupManager::Instance()->GetGroupHighMember(user) == GROUP_HAVE_OFFLINE_HIGH ||
        GroupManager::Instance()->GetGroupHighMember(user) == GROUP_HAVE_ONLINE_HIGH)  
    {
        GroupManager::Instance()->SendAroundMember(user, GroupManager::GET_EXP);
    }
#endif

    user->SetCurBonusEXP(0);
}

// implemented by __NA_0_20090627_HEIM_ACQUISITION_S2S_NOTIFICATION
VOID Handler_AW::OnAW_USER_STATUS_HEIM_ACQUISITION_NTF(AgentServerSession* agent_server, MSG_BASE* msg, WORD size)
{
    const MSG_AW_USER_STATUS_HEIM_ACQUISITION_NTF* recv_msg = 
        static_cast<MSG_AW_USER_STATUS_HEIM_ACQUISITION_NTF*>(msg);

    User* user = UserManager::Instance()->FindUserByCharGuid(recv_msg->m_CharGuid);
    if (user == NULL) 
    {
        return;
    }
    user->SetCurBonusMoney(recv_msg->m_Amount);

    #ifdef _NA_20101026_CHANGE_GROUP_BONUS_APPLY_WAY
        if (GroupManager::Instance()->GetGroupHighMember(user) == GROUP_HAVE_ONLINE_HIGH ||
            GroupManager::Instance()->GetGroupHighMember(user) == GROUP_HAVE_OFFLINE_HIGH)
        {
            GroupManager::Instance()->SendAroundMember(user, GroupManager::GET_MONEY);
        }
    #else
        if (GroupManager::Instance()->GetGroupLowMember(user) == GROUP_HAVE_ONLINE_LOW)
        {
            GroupManager::Instance()->SendAroundMember(user, GroupManager::GET_MONEY);
        }
    #endif

    user->SetCurBonusMoney(0);
}

// implemented by __NA_0_20090627_HEIM_CONSUMPTION_S2S_NOTIFICATION
VOID Handler_AW::OnAW_USER_STATUS_HEIM_CONSUMPTION_NTF(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    const MSG_AW_USER_STATUS_HEIM_CONSUMPTION_NTF* pRecvMsg = 
        static_cast<MSG_AW_USER_STATUS_HEIM_CONSUMPTION_NTF*>(pMsg);

#ifndef _NA_0_20100115_HEIM_LOTTO_TICKET_PURCHASE
    // º¹±Ç¿ëÁö Á÷Á¢ ±¸ÀÔ ±â´ÉÀ» »ç¿ëÇÏÁö ¾Ê´Â °æ¿ì¿¡¸¸ Àû¸³°ú º¹±Ç ¿ëÁö Áö±ÞÀÌ ÀÌ·ç¾îÁø´Ù
    Lotto::GetInstance().OnHeimConsumption(pMsg);
#endif // _NA_0_20100115_HEIM_LOTTO_TICKET_PURCHASE
}

VOID Handler_AW::OnAW_USER_LOTTO_REWARD_ACK(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    Lotto::GetInstance().OnActualReward(pMsg);
}
#ifdef _NA_0_20100115_HEIM_LOTTO_TICKET_PURCHASE
VOID Handler_AW::OnAW_USER_LOTTO_TICKET_PURCHASE_ACK(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    Lotto::GetInstance().OnTicketPurchase(pMsg);
}
#endif // _NA_0_20100115_HEIM_LOTTO_TICKET_PURCHASE


#ifdef _PCBANG_POLICY_CHANGE_POST_EXPIRED
void
Handler_AW::OnAW_USER_STATUS_PCBANG_BILLING_NTF(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    MSG_AW_USER_STATUS_PCBANG_BILLING_NTF* pRecvMsg = static_cast<MSG_AW_USER_STATUS_PCBANG_BILLING_NTF*>(pMsg);
    DWORD user_key = pRecvMsg->m_dwKey;
    User* user = UserManager::Instance()->FindUser(user_key);
    if(user == 0)
    {
        SUNLOG(eCRITICAL_LOG, "["__FUNCTION__"]:[UserGuid:%u]:Can't find user.", user_key);
        return;
    }
    assert(sizeof(*pRecvMsg) == wSize);
    user->SetPCRoomID(pRecvMsg->m_PcRoomId);
#ifdef _NA_006413_20130201_PREMIUMSERVICE_ITEM
    user->SetPremiumService(pRecvMsg->premiumservice_);
#endif //_NA_006413_20130201_PREMIUMSERVICE_ITEM
}
#endif

//_NA_20100812_INTEGRATE_SYSTEM_MEMO_DOMINATION
void
Handler_AW::OnAW_USER_SYSTEMMEMO_SEND_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    const MSG_AW_USER_SYSTEMMEMO_SEND_CMD* recv_msg = 
        static_cast<MSG_AW_USER_SYSTEMMEMO_SEND_CMD*>(pMsg);

    WorldSystemMemo system_memo;
    system_memo.SendSystemMemo(recv_msg->system_memo_info_, 
                               recv_msg->system_memo_list_num_,
                               recv_msg->system_memo_info_->system_memo_type_);
}

void
Handler_AW::OnAW_FRIEND_INVITATIONR_INSERT_CMD(AgentServerSession* pAgentServer, MSG_BASE* pMsg, WORD wSize)
{
    WFriendInvitationController::Instance()->OnAddInvitatedFriendCMD(pAgentServer, pMsg, wSize);
}

#ifdef _NA_004694_20120412_1202_PARTY_ROOM_KEY
void 
Handler_AW::OnAW_PARTY_ROOM_KEY_SYN(AgentServerSession* agentServer_session, MSG_BASE* message, WORD message_size)
{
    MSG_AW_PARTY_ROOM_KEY_SYN* receive_message = static_cast<MSG_AW_PARTY_ROOM_KEY_SYN*>(message);
    Channel* channel = ChannelManager::Instance()->GetChannel( agentServer_session->GetChannelID() );

    if (channel == NULL)
    {
        MessageOut( 
            eCRITICAL_LOG, 
            "PARTY_ROOM_KEY_SYN Error - [C:%u] Channel Not Exist!", 
            receive_message->m_dwKey 
            );
        return;
    }

    channel->SetRoomKey(receive_message->party_key_, receive_message->room_key_);
}
#endif  //_NA_004694_20120412_1202_PARTY_ROOM_KEY

VOID Handler_AW::OnAW_USER_BATTLEGROUND_FALSENAME_CMD( AgentServerSession *pAgentServer, MSG_BASE *pMsg, WORD wSize )
{
#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
    MSG_AW_USER_BATTLEGROUND_FALSENAME_CMD *pRecvMsg = (MSG_AW_USER_BATTLEGROUND_FALSENAME_CMD*)pMsg;

    // ÇØ´ç À¯Á® Æ÷ÀÎÅÍ Ã£±â
    User *pUser = UserManager::Instance()->FindUser( pRecvMsg->m_dwKey );
    if( pUser )
    {
        pUser->SetBattleGroundFalseName(pRecvMsg->false_name);
    }
#endif //_NA_008679_20160202_REWORK_BATTLEGROUND
}