#include "StdAfx.h"
#include "WorldGuildmanager.h"
#include "WorldGuild.h"
#include "WorldGuildMember.h"
#include "WorldGuild.h"
#include "User.h"
#include <PacketStruct_WZ.h>
#include <PacketSTruct_CW.h>
#include <PacketStruct_DW.h>

#include "ServerSession.h"
#include "ServerSessionManager.h"

//WorldGuildManager g_WorldGuildManager;
WorldGuildManager::WorldGuildManager(void)
{
	m_GuildHash.Initialize(MAX_GUILD_POOL_NUM);
}

WorldGuildManager::~WorldGuildManager(void)
{
//	Release();
}

VOID WorldGuildManager::Release()
{
	for( GUILD_HASH::iterator it = m_GuildHash.begin() ; it != m_GuildHash.end() ; ++it )
	{
		(*it)->Destroy();
		WorldGuild::FREE( (*it) );
	}
	m_GuildHash.RemoveAll();
}


// 1. ±æµåÇØ»êÀ» ½ÅûÇÑ ÀÌ°¡ ±æµå¸¶½ºÅÍ¾ß ÇÑ´Ù 
// 2. ÇöÀç ±æµå³»¿¡ ±æµå¿øÀÌ ±æµå¸¶½ºÅÍ 1¸í»ÓÀ̾î¾ß ÇÑ´Ù 
// 3. °ø¼ºÀü¿¡¼­ ½Â¸®ÇÏ¿© ¼ö¼ºÀ»ÇÏ°í ÀÖÁö ¾ÊÀº ±æµå¿©¾ß ÇÑ´Ù. 
RC::eGUILD_RESULT WorldGuildManager::DestroyGuild( User * pUser )
{
	GUILDGUID GuildGuid = pUser->GetGuildGuid();
	if( 0 == GuildGuid )
		return RC::RC_GUILD_CANNOT_DESTROY_STATE;

	WorldGuild * pGuild = FindGuild( GuildGuid );
	if( !pGuild ) return RC::RC_GUILD_INVALID_STATE;

	if( 1 != pGuild->GetMemberNum() )
		return RC::RC_GUILD_CANNOT_DESTROY_EXIST_MEMBER_STATE;
/*
	MSG_GZ_GUILD_DESTROY_GUILD_SYN msg;
	msg.m_GuildGuid			= GuildGuid;
	msg.m_MasterCharGuid	= pUser->GetCharGuid();
	pUser->SendToGuildServer( &msg, sizeof(msg) );
*/
	return RC::RC_GUILD_SUCCESS;
}



VOID WorldGuildManager::DestroyGuild( GUILDGUID GuildGuid )
{
	WorldGuild * pGuild = FindGuild( GuildGuid );
	if( !pGuild )
	{
		SUNLOG( eCRITICAL_LOG,"[WorldGuildManager::DestroyGuild] Fail, GuildGuid = %u", GuildGuid);
		return;
	}

	//1. Manager¿¡¼­ »èÁ¦
	RemoveGuild( pGuild->GetGuildGuid() );
	//2. Memberµé Pool¿¡¼­ »èÁ¦.
	pGuild->Destroy();
	//3. Manager Pool¿¡¼­ »èÁ¦.
	WorldGuild::FREE( pGuild );
}

VOID WorldGuildManager::WithdrawGuild( GUILDGUID GuildGuid, CHARGUID CharGuid )
{
	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )
	{
		SUNLOG( eCRITICAL_LOG,"[WorldGuildManager::WithdrawGuild] Fail, GuildGuid = %u, CharGuid = %u", GuildGuid, CharGuid );
		return;
	}

	pGuild->Withdraw( CharGuid );
}


VOID WorldGuildManager::DisplayerGuildInfo()
{
	DWORD dwNum = 0;
	for( GUILD_HASH::iterator it = m_GuildHash.begin() ; it != m_GuildHash.end() ; ++it )
	{
		dwNum += (*it)->GetMemberNum();
	}
	DISPMSG( "Guild : %u, GuildMember : %u\n", m_GuildHash.GetDataNum(), dwNum );
}

VOID WorldGuildManager::SendGuildMessage( BYTE* pMsg, WORD wSize )
{
}

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
VOID WorldGuildManager::SetChuntingPVPInfo( GUILDGUID GuildGuid, CHUNTING_PVP_INFO & IN PVPInfo )
{
	WorldGuild *pGuild = FindGuild( GuildGuid );
	if( !pGuild )	return;

	pGuild->SetChuntingPVPInfo( PVPInfo );
}
#endif

//±æµå Á÷Ã¥ ¼³Á¤
BOOL WorldGuildManager::ChangeMemberDuty(GUILDGUID GuildGuid, CHARGUID TargetCharGuid, eGUILD_DUTY eGuildDuty)
{
	WorldGuild *pGuild = FindGuild(GuildGuid);
	if(!pGuild)
	{
		SUNLOG( eCRITICAL_LOG, "[WorldGuildManager::ChangeMemberDuty] Guild Not Exist, GuildGuid = %d", GuildGuid );
		return FALSE;
	}

	if( !pGuild->ChangeMemberDuty( TargetCharGuid, eGuildDuty ) )
	{
		SUNLOG( eCRITICAL_LOG, "[WorldGuildManager::ChangeMemberDuty] ChangeMemberDuty Fail, CharGuid = %u, Duty = %d", TargetCharGuid, eGuildDuty );
		return FALSE;
	}

	return TRUE;
}

BOOL	WorldGuildManager::SendGuildPacket( GUILDGUID GuildGuid, BYTE* pMsg, WORD wSize )
{
	WorldGuild *pGuild = FindGuild(GuildGuid);
	if(!pGuild)
	{
		SUNLOG( eCRITICAL_LOG, "[WorldGuildManager::SendGuildPacket] Guild Not Exist, GuildGuid = %d", GuildGuid );
		return FALSE;
	}

	pGuild->SendAllMember( pMsg, wSize );
	return TRUE;
}

BOOL	WorldGuildManager::CreateRearCamp( GUILDGUID GuildGuid, BYTE byCorpsNum )
{
	WorldGuild* pGuild = FindGuild(GuildGuid);
	if(!pGuild)		return FALSE;

	pGuild->CreateRearCamp( byCorpsNum ); 

	return TRUE;
}

BOOL	WorldGuildManager::DestroyRearCamp( GUILDGUID GuildGuid, BYTE byCorpsNum )
{
	WorldGuild* pGuild = FindGuild(GuildGuid);
	if(!pGuild)		return FALSE;

	pGuild->DestroyRearCamp( byCorpsNum ); 

	return TRUE;
}

//±º´ÜÀ庯°æ
VOID		WorldGuildManager::ChangeCommander( GUILDGUID GuildGuid, CHARGUID TargetCharGuid,  BYTE byCorpsNum )
{
	//°ÔÀÓ¼­¹ö¿¡¼­´Â ±º´ÜÀÌ Á¸Àç ÇÏÁö ¾Ê´Â´Ù. 
	//´ÜÁö ±æµå ¸â¹öÀÇ ±º´Ü¹øÈ£°¡ ¹Ù²î°í, Á÷Ã¥ÀÌ ¹Ù²î°Ô µÈ´Ù.
	WorldGuild* pGuild = FindGuild(GuildGuid);
	if( !pGuild )	return;

	WorldGuildMember* pMember = pGuild->FindMember( TargetCharGuid );
	if( !pMember )	return;

	pMember->SetDuty( eGUILD_DUTY_COMMANDER );
	pMember->SetCorpsNum( byCorpsNum );
}

//±º´ÜÀ̵¿.
VOID		WorldGuildManager::ChangeCorps( GUILDGUID GuildGuid,  CHARGUID TargetCharGuid, BYTE byCorpsNum )
{
	WorldGuild* pGuild = FindGuild(GuildGuid);
	if( !pGuild )	return;

	WorldGuildMember* pMember = pGuild->FindMember( TargetCharGuid );
	if( !pMember )	return;

	pMember->SetCorpsNum( byCorpsNum );
}

VOID	WorldGuildManager::CreateGuild( const WORLD_GUILD_INFO& rGuildInfo, const BASE_GUILD_MEMBER_INFO& rMemberInfo )
{
	if( FindGuild( rGuildInfo.m_GuildGuid ) )
	{
		//ÀÌÀü ±æµå°¡ Á¸ÀçÇϸé, ±æµå¸¦ Á¦°Å ÇÑ´Ù.
		TCHAR ptszGuildName[MAX_GUILDNAME_LENGTH+1] = {0,};
		_tcsncpy( ptszGuildName, rGuildInfo.m_tszGuildName, MAX_GUILDNAME_LENGTH );
		RemoveGuild( rGuildInfo.m_GuildGuid );
	}

	WorldGuild* pGuild = WorldGuild::ALLOC();
	pGuild->Create( rGuildInfo, rMemberInfo );
	AddGuild( pGuild, pGuild->GetGuildGuid() );
}

VOID WorldGuildManager::LoginGuild( const WORLD_GUILD_INFO& GuildInfo, const BASE_GUILD_MEMBER_INFO& memberInfo )
{
	WorldGuild* pGuild = FindGuild( GuildInfo.m_GuildGuid );

	// ±æµå°¡ Á¸ÀçÇÏ¸é ¸â¹ö¸¸ »ðÀÔÇÏ°í, ±æµå°¡ Á¸ÀçÇÏÁö ¾ÊÀ¸¸é »õ·Î »ý¼ºÇÑ´Ù.
	if( pGuild )
	{
		pGuild->CreateMember( memberInfo );
	}
	else
	{
		CreateGuild( GuildInfo, memberInfo );
	}
}

RC::eGUILD_RESULT WorldGuildManager::LogoutGuild( GUILDGUID GuildGuid, CHARGUID CharGuid )
{
	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )
		return RC::RC_GUILD_NOT_EXIST_GUILD;

	// ±æµå ¸â¹ö±ä ÇϳÄ?
	WorldGuildMember* pMember = pGuild->FindMember( CharGuid );
	if( !pMember )
		return RC::RC_GUILD_NOT_GUILD_MEMBER;

	// ·Î±× ¾Æ¿ô ÇßÀ¸¹Ç·Î ¿ùµå¼­¹ö °´Ã¼¿¡¼­ Á¦°ÅÇÑ´Ù.
	pGuild->DestroyMember( CharGuid );

	// ¸â¹ö¼ö°¡ 0ÀÌ¸é ±æµå¸¦ Æı«ÇÑ´Ù.
	if( pGuild->GetMemberNum() == 0 )
	{
		pGuild->Destroy();
		RemoveGuild( GuildGuid );
		WorldGuild::FREE( pGuild );
	}

	return RC::RC_GUILD_SUCCESS;
}

VOID	WorldGuildManager::GetCharName( GUILDGUID GuildGuid, CHARGUID CharGuid, OUT char* pszCharName, int nSize )
{
	pszCharName[0] = '\0';

	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )	return;

	WorldGuildMember* pMember = pGuild->FindMember( CharGuid );
	if( !pMember )			return;

	strncpy( pszCharName, pMember->GetCharName(), nSize );
}

// ±æµå Á¤º¸¸¦ º¹±¸ÇÑ´Ù.
// ÀÌ ÇÔ¼ö´Â ¾ÆÁ÷ À¯Àú°¡ ¿ùµå¼­¹ö¿¡ Á¢¼ÓÇϱâ Àü ¿ùµå¼­¹öÀÇ Á¢¼Ó Çã¶ô ´Ü°è¿¡¼­ ÀÌ·ç¾î Áø´Ù.
// µû¶ó¼­ ¾ÆÁ÷ ¿ùµå¼­¹ö¿Í À¯Àú¿Í ¿¬°áÀÌ µÇÁö ¾ÊÀº »óÅÂÀÌ´Ù.
VOID	WorldGuildManager::RequestGuildRestore( GUILDGUID GuildGuid, CHARGUID CharGuid )
{
	ServerSession* pGuildServer = ServerSessionManager::Instance()->GetGuildServer();
	if( !pGuildServer )
	{
		SUNLOG( eCRITICAL_LOG, "[WorldGuildManager::RequestGuildRestore] GuildServer Not Connect, GuildGuid = %u, CharGuid = %u", GuildGuid, CharGuid );
		return;
	}

	//1. ±æµå°¡ ¾øÀ¸¸é ±æµå Á¤º¸ ¿äûÇÑ´Ù. ±æµå Á¤º¸ ¿äû½Ã¿¡ ij¸¯ÅÍ Á¤º¸±îÁö °°ÀÌ ¿äûÇÑ´Ù.
	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )
	{
		MSG_WZ_GUILD_RESTORE_SYN	synMsg;
		synMsg.m_GuildGuid = GuildGuid;
		synMsg.m_CharGuid = CharGuid;
		pGuildServer->Send( (BYTE*)&synMsg, sizeof(synMsg) );
		return;
	}

	//3. ±æµå°¡ Á¸ÀçÇϴµ¥ ¸â¹ö°¡ ¾øÀ¸¸é ¸â¹ö Á¤º¸¸¦ ¿äûÇÑ´Ù.
	WorldGuildMember* pMember = pGuild->FindMember( CharGuid );
	if( !pMember )
	{
		//±æµå¸â¹ö Á¤º¸ ¿äû.
		MSG_WZ_GUILD_MEMBER_INFO_REQ_SYN	msg;
		msg.m_GuildGuid = GuildGuid;
		msg.m_CharGuid = CharGuid;
		pGuildServer->Send( (BYTE*)&msg, sizeof(msg) );
		return;
	}
	
}

VOID	WorldGuildManager::GuildRestore( const WORLD_GUILD_INFO& GuildInfo, const BASE_GUILD_MEMBER_INFO& memberInfo )
{
	WorldGuild* pGuild = FindGuild( GuildInfo.m_GuildGuid );

	//1. ±âÁ¸±æµå°¡ ÀÖÀ¸¸é ±æµå ¸â¹ö¸¸ º¹±¸ÇÑ´Ù.
	if( pGuild )
	{
		pGuild->CreateMember( memberInfo );
	}
	else
	{
		CreateGuild( GuildInfo, memberInfo );
	}
}

VOID	WorldGuildManager::SerializeWorldGuildInfo( GUILDGUID GuildGuid, INOUT WORLD_GUILD_INFO& Info, eSERIALIZE se )
{
	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )		return;
	
	pGuild->SerializeWorldGuildInfo( Info, se );
}

VOID	WorldGuildManager::SerializeBaseMemberInfo( GUILDGUID GuildGuid, INOUT BASE_GUILD_MEMBER_INFO& Info, eSERIALIZE se )
{
	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )		return;
	
	pGuild->SerializeBaseMemberInfo( Info, se );
}


//VOID	WorldGuildManager::SerializeBaseMemberTotalInfo( GUILDGUID GuildGuid, INOUT BASE_GUILD_MEMBER_TOTAL_INFO& Info, eSERIALIZE se )
//{
//	WorldGuild* pGuild = FindGuild( GuildGuid );
//	if( !pGuild )		return;

//	pGuild->SerializeBaseMemberTotalInfo( Info, se );
//}

VOID	WorldGuildManager::KickMember(  GUILDGUID GuildGuid, CHARGUID CharGuid )
{
	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )		return;

	pGuild->DestroyMember( CharGuid );
}

VOID	WorldGuildManager::JoinGuild( GUILDGUID GuildGuid, const BASE_GUILD_MEMBER_INFO& rMemberInfo )
{
	WorldGuild * pGuild = FindGuild( GuildGuid );
	if( !pGuild )		return;

	pGuild->Join(rMemberInfo);
}


RC::eGUILD_RESULT	WorldGuildManager::CanChangeNotice( GUILDGUID GuildGuid, CHARGUID OperCharGuid, const TCHAR* pszNotice, OUT int& nNoticeLen )
{
	nNoticeLen = 0;

	WorldGuild* pGuild = FindGuild( GuildGuid );
	if( !pGuild )
		return RC::RC_GUILD_NOT_EXIST_GUILD;

	WorldGuildMember* pMember = pGuild->FindMember( OperCharGuid );
	if( !pMember )
		return RC::RC_GUILD_NOT_GUILD_MEMBER;

	const SIZE_T noticeLen = strlen( pszNotice );
	if( noticeLen > MAX_GUILDNOTICE_LENGTH )
		return RC::RC_GUILD_STRING_OVERFLOW;

	nNoticeLen = (INT)noticeLen;

	return RC::RC_GUILD_SUCCESS;
}

bool WorldGuildManager::ChangeNotice(
    GUILDGUID guild_guid, const util::StrArrayForGuildNotice& notice)
{
    WorldGuild* guild = FindGuild(guild_guid);
    if (guild == NULL) {
        return false;
    };
    guild->SetGuildNotice(notice);
    return true;
}


VOID WorldGuildManager::SendDominationHeimReturnMemo(const MSG_WZ_GUILD_DOMINATION_RETURNHIME_CMD* msg)
{    
    BYTE data_count = msg->m_DataCount;

    if (data_count > _countof(msg->m_ReturnInfo)) //MAX_DOMINATION_AUCTION
    {
        assert(!"Memo count is over");
        SUNLOG(eCRITICAL_LOG,  __FUNCTION__"Memo count is over : %d", msg->m_MapCode);
        return;
    }

    for (int index = 0; index < data_count; ++index)
    {
        MSG_DW_MEMO_SEND_SYN send_msg;
        send_msg.m_dwKey = 0;    // ½Ã½ºÅÛÀ¸·ÎºÎÅÍÀÇ ÂÊÁö
        send_msg.m_SendGuid = 0; // ½Ã½ºÅÛÀ¸·ÎºÎÅÍÀÇ ÂÊÁö
        //_NA_20100812_INTEGRATE_SYSTEM_MEMO_DOMINATION = {
        send_msg.m_typeSystemMemo = NORMAL_MEMO;
        send_msg.m_recvItemCode = 0;
        send_msg.m_amountCost = 0;
        send_msg.m_recvGuid = 0;
        //}
        _tcsncpy(send_msg.m_ptszRecvName, msg->m_ReturnInfo[index].m_tszMaster,
                 _countof(send_msg.m_ptszRecvName));
        send_msg.m_ptszRecvName[_countof(send_msg.m_ptszRecvName) - 1]='\0';

        _sntprintf(send_msg.m_ptszMemo, _countof(send_msg.m_ptszMemo), "%d|%d|%I64d|%s|", 
                   msg->m_ReturnInfo[index].m_CostType, 
                   msg->m_MapCode,
                   msg->m_ReturnInfo[index].m_TenderCost,
                   msg->m_tszGuild );
        send_msg.m_ptszMemo[_countof(send_msg.m_ptszMemo) - 1] = '\0';

        ServerSession* game_DB_proxy = ServerSessionManager::Instance()->GetGameDBProxy();
        if (game_DB_proxy == NULL)
        {
            SUNLOG(eCRITICAL_LOG,  "["__FUNCTION__"]No GameDBProxy");
            return ;
        }
        game_DB_proxy->Send((BYTE*)&send_msg, sizeof(send_msg));
    }
}

BOOL WorldGuildManager::GetValueInMemo(const TCHAR* pszMemo, eSYSTEM_MEMO_TYPE& OUT type,
                                       MAPCODE& OUT mapcode)
{ 
    std::string strMemo;
    strMemo.assign(pszMemo);
    std::string::size_type firstPos;
    std::string::size_type secondPos;

    //ù¹ø° : ŸÀÔÀ» ¾ò´Â´Ù.
    firstPos = 0;
    secondPos = strMemo.find('|');
    if (firstPos != std::string::npos) 
    {
        std::string tempString = strMemo.substr(firstPos, secondPos);
        type =(eSYSTEM_MEMO_TYPE) atoi( tempString.c_str() );
    }
    else
    {
        MessageOut( eCRITICAL_LOG, "["__FUNCTION__"]Not Fount Memo Type" );
        return FALSE;
    }

    //µÎ¹ø° : MapCode¸¦ ¾ò´Â´Ù.
    firstPos = strMemo.find('|');
    secondPos = strMemo.find('|', firstPos+1);
    if( secondPos != std::string::npos )
    {
        std::string tempString = strMemo.substr(firstPos+1, secondPos-1);
        mapcode = atoi( tempString.c_str() );
    }
    else
    {
        MessageOut( eCRITICAL_LOG, "["__FUNCTION__"]Not Fount mapcode" );
        return FALSE;
    }

    return TRUE;
}