#include "stdafx.h"
#include "PartyDBMgr.h"
#include "PartyDBInfo.h"

#include <Network/SendPacket/SendParty.h>
#include <Network/Dispatch/GameDispatch.h>

#include <DataStorage/CharacterData.h>
#include <DataStorage/CharacterDataMgr.h>

#include <DataStorage/SessionData.h>
#include <DataStorage/SessionDataMgr.h>

#include <DB/DBComponent.h>
#include <DB/GameDBComponent.h>

#include <Log/ServerLog.h>

#include <Network/Packet/PacketStruct/PartyPacket.h>
#include <Network/Packet/PacketCommand.h>

#include <new>

namespace DBAgent
{

CPartyDBMgr& CPartyDBMgr::GetInstance()
{
    static CPartyDBMgr partyDBMgr;
    return partyDBMgr;
}

CPartyDBMgr::CPartyDBMgr()
:   m_PartyDBPool(sizeof(CPartyDBInfo))
{

}


CPartyDBInfo* CPartyDBMgr::CreatePartyDBInfo(unsigned long dwPID)
{
    return new CPartyDBInfo(dwPID);

    // return new (m_PartyDBPool.malloc()) CPartyDBInfo(dwPID);
}

void CPartyDBMgr::DeletePartyDBInfo(CPartyDBInfo* lpPartyDBInfo)
{
    delete lpPartyDBInfo;

    // lpPartyDBInfo->~CPartyDBInfo(); 
    // m_PartyDBPool.free(lpPartyDBInfo);
}


CPartyDBMgr::~CPartyDBMgr()
{
    PartyMap::iterator pos = m_PartyMap.begin();
    PartyMap::iterator end = m_PartyMap.end();

    for(; pos != end; ++pos)
    {
        DeletePartyDBInfo(pos->second);
    }

    m_PartyMap.clear();
}



bool CPartyDBMgr::InsertPartyMap(unsigned long dwPartyID, CPartyDBInfo* lpParty)
{
	m_PartyMap.insert(std::make_pair(dwPartyID, lpParty)).second;
	return true;
}

bool CPartyDBMgr::DeletePartyMap(unsigned long dwPartyID)
{
	PartyMap::iterator itr = m_PartyMap.find(dwPartyID);
	if (itr == m_PartyMap.end())
    {
        return false;
    }

    itr->second->~CPartyDBInfo();
	DeletePartyDBInfo(itr->second);

	m_PartyMap.erase(dwPartyID);
	return true;
}

CPartyDBInfo* CPartyDBMgr::FindPartyMap(unsigned long dwPartyID_In)
{
	PartyMap::iterator itr = m_PartyMap.find(dwPartyID_In);
	if (itr == m_PartyMap.end())	
    {	
        return 0;	
    }
	
	return itr->second;
}

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

CPartyDBInfo* CPartyDBMgr::OpenParty(CDBComponent& DBComponent, unsigned long dwPartyID)
{
    CPartyDBInfo* lpParty = 0;

	if (0 != dwPartyID)
	{
		lpParty = FindPartyMap(dwPartyID);

		if (0 == lpParty)
		{
			// ÆÄƼ Á¤º¸ »ý¼º
			PARTY_DB_INFO PartyDBInfo = {0,};			

            if (!DBComponent::GameDB::GetPartyInfo(DBComponent, dwPartyID, &PartyDBInfo)) 
			{
				ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼÀÇ GetPartyInfoÀ» È£ÃâÇϴµ¥ ½ÇÆÐÇß½À´Ï´Ù.", dwPartyID);
				return 0;
			}
			
			lpParty = CreatePartyDBInfo(dwPartyID);
			if (0 == lpParty) 
			{
				ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ Á¤º¸ »ý¼º¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù.", dwPartyID);
				return 0;
			}

			if (!lpParty->SerializeIn(PartyDBInfo.PartyInfo, PartyDBInfo.PartyUserInfo)) 
			{
				ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ Á¤º¸ Serialize¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù.", dwPartyID);
				return 0;
			}

			// ÆÄƼ ¸Ê¿¡ Ãß°¡
			InsertPartyMap(dwPartyID, lpParty);
		}
	}

	return lpParty;
}

bool CPartyDBMgr::CloseParty(CDBComponent& DBComponent, unsigned long dwPartyID)
{
	CPartyDBInfo* lpParty = OpenParty(DBComponent, dwPartyID);
	if (0 == lpParty) 
	{
        ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ¿­±â ½ÇÆÐ", dwPartyID);	
		return false;
	}

	PARTY_DB_INFO PartyInfo = {0,};

	if (!lpParty->SerializeOut(PartyInfo.PartyInfo, PartyInfo.PartyUserInfo)) 
	{
		return false;
	}

    if (!DBComponent::GameDB::UpdatePartyInfo(DBComponent, dwPartyID, &PartyInfo))
	{
		ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼÀÇ UpdatePartyInfo¸¦ È£ÃâÇϴµ¥ ½ÇÆÐÇß½À´Ï´Ù.", dwPartyID);
		return false;
	}

	RULLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ´Ý±â.", dwPartyID);
	return DeletePartyMap(dwPartyID);
}

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

CPartyDBInfo* CPartyDBMgr::CreateParty(CDBComponent& DBComponent, unsigned long dwLeaderID, char cLeaderLevel, unsigned short wLeaderClass, unsigned long dwLeaderGID,
                                       unsigned long dwMemberID, char cMemberLevel, unsigned short wMemberClass, unsigned long dwMemberGID)
{
    using namespace DataStorage;

    CSessionData* lpLeaderSessionData = 
        CSessionDataMgr::GetInstance().GetCharLoadedSession(dwLeaderID);

    CSessionData* lpMemberSessionData = 
        CSessionDataMgr::GetInstance().GetCharLoadedSession(dwMemberID);

    CCharacterData* lpLeaderCharData = 0;
    CCharacterData* lpMemberCharData = 0;

    CPartyDBInfo* lpParty = 0;

    // ¾ò¾î¿Â ¼¼¼Ç ¹«°á¼º °Ë»ç.
	if (0 == lpLeaderSessionData || 0 == lpMemberSessionData) 
	{
        ERRLOG4(g_Log, "ÆÄƼ ·Î±× : LeaderCID:%10u(0x%p) / MemberCID:%10u(0x%p) / "
            "ÆÄƼ »ý¼º ¿¡·¯ : ¼¼¼ÇÀÌ ¾ø½À´Ï´Ù.", 
            dwLeaderID, lpLeaderSessionData, dwMemberID, lpMemberSessionData);
	}
    else if(CSessionData::SE_CHAR_ENABLED != lpLeaderSessionData->GetSessionState() || 
        CSessionData::SE_CHAR_ENABLED != lpMemberSessionData->GetSessionState())
    {
        ERRLOG4(g_Log, "ÆÄƼ ·Î±× : LeaderCID:%10u(ST:%s) / MemberCID:%10u(ST:%s) / "
            "ÆÄƼ »ý¼º ¿¡·¯ : ¼¼¼Ç »óÅ°¡ È°¼ºÈ­µÇÁö ¾Ê¾Ò½À´Ï´Ù.", 
            dwLeaderID, g_szSessionStateString[lpLeaderSessionData->GetSessionState()], 
            dwMemberID, g_szSessionStateString[lpMemberSessionData->GetSessionState()]);
    }
    else if(0 == (lpLeaderCharData = lpLeaderSessionData->GetCharacterData()) ||
        0 == (lpMemberCharData = lpMemberSessionData->GetCharacterData()))
    {
        ERRLOG4(g_Log, "ÆÄƼ ·Î±× : LeaderCID:%10u(CharData:0x%p) / MemberCID:%10u(CharData:0x%p) / "
            "ÆÄƼ »ý¼º ¿¡·¯ : ij¸¯ÅÍ µ¥ÀÌÅÍ°¡ ¾ø½À´Ï´Ù.", 
            dwLeaderID, lpLeaderCharData, dwMemberID, lpMemberCharData);;
    }
    else
    {
	    PARTY_DB_INFO PartyInfo = {0,};

	    PartyInfo.PartyInfo.MemberCID[0]	= lpLeaderCharData->GetCID();
		PartyInfo.PartyUserInfo.m_cLevel[0]	= cLeaderLevel;
		PartyInfo.PartyUserInfo.m_wClass[0]	= wLeaderClass;
		PartyInfo.PartyUserInfo.m_dwGID[0]	= dwLeaderGID;
		strncpy(PartyInfo.PartyInfo.Name[0], lpLeaderCharData->GetName(), CHAR_INFOST::MAX_NAME_LEN);

	
	    PartyInfo.PartyInfo.MemberCID[1] = lpMemberCharData->GetCID();    
		PartyInfo.PartyUserInfo.m_cLevel[1]	= cMemberLevel;
		PartyInfo.PartyUserInfo.m_wClass[1]	= wMemberClass;
		PartyInfo.PartyUserInfo.m_dwGID[1]	= dwMemberGID;		
	    strncpy(PartyInfo.PartyInfo.Name[1], lpMemberCharData->GetName(), CHAR_INFOST::MAX_NAME_LEN);		
		
	    // DB ÆÄƼ »ý¼º
	    unsigned long dwPartyID = 0;

        if (!DBComponent::GameDB::InsertParty(DBComponent, &PartyInfo, &dwPartyID)) 
	    {
            ERRLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / LeaderCID:%10u / MemberCID:%10u / "
                "ÆÄƼ »ý¼º ¿¡·¯ : ÆÄƼÀÇ InsertPartyÀ» È£ÃâÇϴµ¥ ½ÇÆÐÇß½À´Ï´Ù.", 
                dwPartyID, dwLeaderID, dwMemberID);
	    }
        else if (0 == dwPartyID)
	    {
		    ERRLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / LeaderCID:%10u / MemberCID:%10u / "
                "ÆÄƼ »ý¼º ¿¡·¯ : DB¿¡¼­ ÆÄƼ »ý¼º¿¡ ½ÇÆÐÇß½À´Ï´Ù.",
                dwPartyID, dwLeaderID, dwMemberID);
	    }
        else if (0 == (lpParty = CreatePartyDBInfo(dwPartyID)))
        {
            ERRLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / LeaderCID:%10u / MemberCID:%10u / "
                "ÆÄƼ »ý¼º ¿¡·¯ : CPartyDBInfo»ý¼º ½ÇÆÐ",
                dwPartyID, dwLeaderID, dwMemberID);
        }
        else if (!lpParty->SerializeIn(PartyInfo.PartyInfo, PartyInfo.PartyUserInfo)) 
	    {
            DeletePartyDBInfo(lpParty);
            lpParty = 0;
		    
            ERRLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / LeaderCID:%10u / MemberCID:%10u / "
                "ÆÄƼ »ý¼º ¿¡·¯ : ÆÄƼ µ¥ÀÌÅÍ Serialize ½ÇÆÐ",
                dwPartyID, dwLeaderID, dwMemberID);
	    }
        else
        {
	        lpParty->PartyMemLogin(dwLeaderID, lpLeaderSessionData->GetServerID());
            lpParty->PartyMemLogin(dwMemberID, lpMemberSessionData->GetServerID());

	        InsertPartyMap(dwPartyID, lpParty);

            RULLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / LeaderCID:%10u / MemberCID;%10u / "
                "ÆÄƼ »ý¼º ¼º°ø ", dwPartyID, dwLeaderID, dwMemberID);
        }
    }

    return lpParty;
}

bool CPartyDBMgr::DestoryParty(CDBComponent& DBComponent, unsigned long dwPartyID)
{
	CPartyDBInfo* lpParty = FindPartyMap(dwPartyID);
	if (0 == lpParty)
	{
        ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ¼Ò¸ê ½ÇÆÐ : ÆÄƼ°¡ ¾ø½À´Ï´Ù", dwPartyID);
		return false;
	}

	if (MIN_MEMBER_NUM != lpParty->GetPartyMemNum()) 
	{
        ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ¼Ò¸ê ½ÇÆÐ : Àοø¼ö°¡ ÃÖ¼ÒÀοøÀÌ ¾Æ´Õ´Ï´Ù", dwPartyID);
		return false;
	}

	PARTY_DB_INFO PartyInfo = {0,};
	if (!lpParty->SerializeOut(PartyInfo.PartyInfo, PartyInfo.PartyUserInfo)) 
	{
        ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ¼Ò¸ê ½ÇÆÐ : µ¥ÀÌÅ͸¦ ¾ò¾î¿Ã ¼ö ¾ø½À´Ï´Ù", dwPartyID);
		return false;
	}

    if (!DBComponent::GameDB::DeleteParty(DBComponent, &PartyInfo, dwPartyID)) 
	{
        ERRLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ¼Ò¸ê ½ÇÆÐ : DBÈ£Ãâ DeletePartyÀ» ½ÇÆÐÇß½À´Ï´Ù.", dwPartyID);
		return false;
	}

	// ij½¬ DB¿¡ ÀúÀåµÇ¾î Àִ ij¸¯ÅÍ´Â PID Àç¼³Á¤ ÇØÁÖ¾î¾ß ÇÑ´Ù.	
    using namespace DataStorage;

    CCharacterData* lpMember = 0;
	for (unsigned long nCount = 0; nCount < lpParty->GetPartyMemNum(); ++nCount)
	{
		if (0 == lpParty->IsLoginedByIndex(nCount))
		{
            lpMember = static_cast<CCharacterData*>(CCharacterDataMgr::GetInstance().GetLogoutData(PartyInfo.PartyInfo.MemberCID[nCount]));

			if (0 != lpMember)
			{
				if (dwPartyID == lpMember->GetPID())
				{					
                    RULLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:10u / ÆÄƼ ¼Ò¸ê Á¤º¸ : ÆÄƼ ¼Ò¸ê·Î,  ij½¬ ij¸¯ÅÍÀÇ PIDÁö¿ò", 
                        dwPartyID, PartyInfo.PartyInfo.MemberCID[nCount]);

                    lpMember->SetPID(0);
				}
			}
		}
	}

    SendPacket::DeleteParty(lpParty);

    RULLOG1(g_Log, "ÆÄƼ ·Î±× : PID:%10u / ÆÄƼ ¼Ò¸ê ¼º°ø", dwPartyID);
	return DeletePartyMap(dwPartyID);
}

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

bool CPartyDBMgr::InsertPartyMember(CDBComponent& DBComponent, unsigned long dwPartyID, unsigned long dwCharID, unsigned long dwGID,
										unsigned short wClass, char cLevel)
{
    using namespace DataStorage;

    CSessionData*   lpInsertMember = CSessionDataMgr::GetInstance().GetCharLoadedSession(dwCharID);
    CCharacterData* lpInsertMemberCharData = 0;
    CPartyDBInfo*   lpParty = 0;

    PARTY_DB_INFO PartyInfo = {0,};	

    if(0 == lpInsertMember)
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : ÆÄƼ ¸â¹ö°¡ ¾ø½À´Ï´Ù",
            dwPartyID, dwCharID);

		return false;
    }
    else if(0 == (lpParty = OpenParty(DBComponent, dwPartyID)))
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : ij¸¯ÅÍÀÇ ÆÄƼ ¿­±â ½ÇÆÐ",
            dwPartyID, dwCharID);

		return false;
    }
    else if(0 == (lpInsertMemberCharData = lpInsertMember->GetCharacterData()))
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : ¼¼¼Ç¿¡ ij¸¯ÅÍ µ¥ÀÌÅÍ ¾øÀ½",
            dwPartyID, dwCharID);

		return false;
    }
    else if(!lpParty->InsertPartyMem(lpInsertMember->GetServerID(), dwCharID, wClass, cLevel, dwGID, lpInsertMemberCharData->GetName()))
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : ÆÄƼ¿¡ ij¸¯ÅÍ Ãß°¡ ½ÇÆÐ",
            dwPartyID, dwCharID);

		return false;
    }
    
	if(!lpParty->SerializeOut(PartyInfo.PartyInfo, PartyInfo.PartyUserInfo)) 
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : ÆÄƼ µ¥ÀÌÅÍ ¾ò±â ½ÇÆÐ",
            dwPartyID, dwCharID);

		return false;
	}
    else if(!DBComponent::GameDB::InsertPartyMember(DBComponent, dwPartyID, &PartyInfo, dwCharID))
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : DB¿¡ InsertPartyMember È£Ãâ ½ÇÆÐ",
            dwPartyID, dwCharID);

		return false;
    }
    else if(!SendPacket::PartyCmd(PktDD::SCmdInsertPartyMem, lpParty->GetPID(), dwCharID, dwGID,
				wClass, lpInsertMember->GetServerID(), cLevel, lpInsertMemberCharData->GetName()))
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ½ÇÆÐ : °ÔÀÓ¼­¹ö¿¡ ÆÄƼ º¯°æ Àü¼Û ½ÇÆÐ",
            dwPartyID, dwCharID);

		return false;
    }
    else
    {
        DETLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö Ãß°¡ ¼º°ø", dwPartyID, dwCharID);
        return true;
    }

	return false;
}

bool CPartyDBMgr::DeletePartyMember(CDBComponent& DBComponent, unsigned long dwPartyID, 
                                    unsigned long dwCharID, unsigned long dwReference)
{
	CPartyDBInfo* lpParty = OpenParty(DBComponent, dwPartyID);
	if (0 == lpParty) 
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö »èÁ¦ ½ÇÆÐ : ÆÄƼ ¿­±â ½ÇÆÐ",
            dwPartyID, dwCharID);

        return false;
	}
    else if (MIN_MEMBER_NUM == lpParty->GetPartyMemNum())
	{
        // ¸â¹ö°¡ ÀÛÀ¸¸é ÆÄƼ¸¦ ±ú¹ö¸°´Ù.
		return DestoryParty(DBComponent, dwPartyID);
	}

	unsigned long dwServerID = 0;
	unsigned long dwOldLeader = lpParty->GetLeader();
	if (!lpParty->DeletePartyMem(dwCharID, dwServerID))
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö »èÁ¦ ½ÇÆÐ : ÆÄƼ ¸â¹ö »èÁ¦ ½ÇÆÐ",
            dwPartyID, dwCharID);

		return false;
	}

    DETLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö »èÁ¦ ¼º°ø", dwPartyID, dwCharID);

	PARTY_DB_INFO PartyInfo = {0,};
	if (!lpParty->SerializeOut(PartyInfo.PartyInfo, PartyInfo.PartyUserInfo)) 
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö »èÁ¦ ½ÇÆÐ : ÆÄƼ ¸â¹ö µ¥ÀÌÅÍ ¾ò±â ½ÇÆÐ",
            dwPartyID, dwCharID);
        
        return false;
	}
    else if(!DBComponent::GameDB::DeletePartyMember(DBComponent, dwPartyID, &PartyInfo, dwCharID)) 
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö »èÁ¦ ½ÇÆÐ : DB¿¡ DeletePartyMember È£Ãâ ½ÇÆÐ",
            dwPartyID, dwCharID);
		
		return false;
	}

	// ¸®´õ üũ
    unsigned long dwLeader = lpParty->GetLeader();
	if (dwOldLeader != dwLeader)
	{
        // ÆÄƼ ¸®´õ°¡ ¹Ù²ñ
		dwReference = dwLeader;
	}	

    if(!SendPacket::PartyCmd(PktDD::SCmdDeletePartyMem, lpParty->GetPID(), dwCharID, dwReference, 0, 0, 0, "»èÁ¦"))
    {
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö »èÁ¦ ½ÇÆÐ : °ÔÀÓ¼­¹ö·Î ¸®´õ ¹Ù²ñ Àü¼Û ½ÇÆÐ",
            dwPartyID, dwCharID);
    }

	if (0 == dwLeader)
	{
        // ¸®´õ°¡ ¾øÀ¸¸é ÆÄƼ¸¦ ´Ý´Â´Ù.
		if(CloseParty(DBComponent, dwPartyID))
        {
            DETLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / Leader:%10u / ÆÄƼ ¸â¹ö »èÁ¦ : ÆÄƼ ¸®´õ°¡ ¾ø¾î¼­ ÆÄƼ¸¦ ´Ý½À´Ï´Ù.",
                dwPartyID, dwCharID, dwLeader);
        }
    }

    return true;
}

bool CPartyDBMgr::AutoRoutingOn(CDBComponent& DBComponent, unsigned long dwPartyID, unsigned long dwCharID)
{
	// CharID °¡ 0 À̸é ALL
	CPartyDBInfo* lpParty = OpenParty(DBComponent, dwPartyID);
	if (0 == lpParty) 
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ¿ÀÅä ·çÆà ON ½ÇÆÐ : ÆÄƼ°¡ ¾ø½À´Ï´Ù",
            dwPartyID, dwCharID);	
		return false;
	}
	
	if (!lpParty->AutoRouting(dwCharID, true, (0 == dwCharID) ? true : false))
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ¿ÀÅä ·çÆà ON ½ÇÆÐ : ¿ÀÅä ·çÆà Äѱ⠽ÇÆÐ (CID°¡ 0ÀÌ¸é ¸ðµÎ)",
            dwPartyID, dwCharID);	

        return false;
	}

    return SendPacket::PartyCmd(PktDD::SCmdAutoRoutingOn, lpParty->GetPID(), dwCharID, 0, 0, 0, 0, 0);	
}

bool CPartyDBMgr::AutoRoutingOff(CDBComponent& DBComponent, unsigned long dwPartyID, unsigned long dwCharID)
{
	// CharID °¡ 0 À̸é ALL
	CPartyDBInfo* lpParty = OpenParty(DBComponent, dwPartyID);
	if (0 == lpParty) 
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ¿ÀÅä ·çÆà OFF ½ÇÆÐ : ÆÄƼ°¡ ¾ø½À´Ï´Ù",
            dwPartyID, dwCharID);	
		return false;
	}
	
	if (false == lpParty->AutoRouting(dwCharID, false, (0 == dwCharID) ? true : false))
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ¿ÀÅä ·çÆà OFF ½ÇÆÐ : ¿ÀÅä ·çÆà Äѱ⠽ÇÆÐ (CID°¡ 0ÀÌ¸é ¸ðµÎ)",
            dwPartyID, dwCharID);	

        return false;
	}

    return SendPacket::PartyCmd(PktDD::SCmdAutoRoutingOff, lpParty->GetPID(), dwCharID, 0, 0, 0, 0, 0);	
}

void CPartyDBMgr::LoginPartyMember(CPartyDBInfo* lpParty, unsigned long dwUserID, unsigned long dwCharID, unsigned long dwGID, 
                                   unsigned short wClass, unsigned long dwServerID, char cLevel)
{
	if (0 == lpParty) 
	{
        ERRLOG3(g_Log, "ÆÄƼ ·Î±× : UID:%10u / CID:%10u / ServerID:0x%08X / "
            "ÆÄƼ ¸â¹ö ·Î±×ÀÎ ½ÇÆÐ : ÆÄƼ°¡ ¾ø½À´Ï´Ù", dwUserID, dwCharID, dwServerID);		
	}
    else if (!lpParty->IsMember(dwCharID))
	{
        ERRLOG4(g_Log, "ÆÄƼ ·Î±× : PID:%10u / UID:%10u / CID:%10u / ServerID:0x%08X / "
            "ÆÄƼ ¸â¹ö ·Î±×ÀÎ ½ÇÆÐ : ÆÄƼ ¸â¹ö°¡ ¾Æ´Õ´Ï´Ù", 
            lpParty->GetPID(), dwUserID, dwCharID, dwServerID);		
	}
    else
    {
        unsigned long dwPartyID	= lpParty->GetPID();

        // Á¢¼Ó DB¿¡¼­ ¼¼¼Ç È®ÀÎ

        using namespace DataStorage;

        CSessionData*   lpSessionData = CSessionDataMgr::GetInstance().GetCharLoadedSession(dwCharID);
        CCharacterData* lpCharacterData = 0;

        if (0 == dwPartyID || 0 == lpSessionData || 0 == (lpCharacterData = lpSessionData->GetCharacterData()))
        {
            ERRLOG6(g_Log, "ÆÄƼ ·Î±× : PID:%10u / UID:%10u / CID:%10u(Session:0x%p/Character:0x%p) / ServerID:0x%08X / "
                "ÆÄƼ ¸â¹ö ·Î±×ÀÎ ½ÇÆÐ : ¼¼¼Ç ȤÀº ij¸¯ÅÍ µ¥ÀÌÅÍ°¡ ¾ø½À´Ï´Ù", 
                dwPartyID, dwUserID, dwCharID, lpSessionData, lpCharacterData, dwServerID);		
        }
        else if (lpCharacterData->GetPID() != dwPartyID)
        {
            ERRLOG5(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CharacterDataPID:%10u / UID:%10u / CID:%10u / ServerID:0x%08X / "
                "ÆÄƼ ¸â¹ö ·Î±×ÀÎ ½ÇÆÐ : ¿äû PID¿Í ij¸¯ÅÍ PID°¡ ´Ù¸¨´Ï´Ù",
                dwPartyID, lpCharacterData->GetPID(), dwUserID, dwCharID, dwServerID);
        }
        else if (!lpParty->PartyMemLogin(dwCharID, dwServerID))
        {
            GET_MULTI_DISPATCH(lpGameDispatch, dwServerID,
                DBAgent::CGameDispatch, DBAgent::CGameDispatch::GetDispatchTable());

            if(0 != lpGameDispatch)
            {
                ERRLOG4(g_Log, "ÆÄƼ ·Î±× : PID:%10u / UID:%10u / CID:%10u / ServerID:0x%08X / "
                    "ÆÄƼ ¸â¹ö ·Î±×ÀÎ ½ÇÆÐ : ÆÄƼ ·Î±×ÀÎ ½ÇÆÐ", 
                    dwPartyID, dwUserID, dwCharID, dwServerID);		                				

                SendPacket::PartyCmd(lpGameDispatch->GetSendStream(), PktDD::SCmdLoginPartyMem, 
                    dwPartyID, dwCharID, dwGID, wClass, dwServerID, cLevel, lpCharacterData->GetName(), 2);
            }
        }
        else
        {
            DETLOG4(g_Log, "ÆÄƼ ·Î±× : PID:%10u / UID:%10u / CID:%10u / ServerID:0x%08X / "
                "ÆÄƼ ¸â¹ö ·Î±×ÀÎ ¼º°ø", dwPartyID, dwUserID, dwCharID, dwServerID);		

			CPartyDBInfo* lpParty = CPartyDBMgr::GetInstance().OpenParty(CDBSingleObject::GetInstance(), dwPartyID);

			if(lpParty)
			{
				// ij¸¯ÅÍ Á¤º¸ ¾÷µ¥ÀÌÆ® //
				lpParty->SetUserInfoLevel(dwCharID, cLevel);
				lpParty->SetUserInfoClass(dwCharID, wClass);
				lpParty->SetUserInfoGID(dwCharID, dwGID);
			}

            SendPacket::PartyCmd(PktDD::SCmdLoginPartyMem, lpParty->GetPID(), 
                dwCharID, dwGID, wClass, dwServerID, cLevel, lpCharacterData->GetName());
        }
    }
}

void CPartyDBMgr::LogoutPartyMember(CDBComponent& DBComponent, CPartyDBInfo* lpParty, unsigned long dwCharID)
{
	if (0 == lpParty)
	{
        ERRLOG1(g_Log, "ÆÄƼ ·Î±× : CID:%10u / ÆÄƼ ¸â¹ö ·Î±×¾Æ¿ô ½ÇÆÐ : ÆÄƼ ¿­±â ½ÇÆÐ", dwCharID);		
	}
    else if (!lpParty->IsMember(dwCharID))
	{
        ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö ·Î±×¾Æ¿ô ½ÇÆÐ : ÆÄƼ¿øÀÌ ¾Æ´Õ´Ï´Ù", 
            lpParty->GetPID(), dwCharID);

    }
    else
    {
	    unsigned long dwPartyID     = lpParty->GetPID();
	    unsigned long dwOldLeader   = lpParty->GetLeader();

	    if (!lpParty->PartyMemLogout(dwCharID))
	    {
            ERRLOG2(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / ÆÄƼ ¸â¹ö ·Î±×¾Æ¿ô ½ÇÆÐ : ¸â¹ö ·Î±×¾Æ¿ô ½ÇÆÐ",
                dwPartyID, dwCharID);		    
	    }
        else
        {
	        unsigned long dwLeader = lpParty->GetLeader();
	        unsigned long dwReference = 0;
	        if (dwOldLeader != dwLeader)
	        {
		        dwReference = dwLeader;
	        }

            DETLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / NewLeader:%10u / ÆÄƼ ¸â¹ö ·Î±×¾Æ¿ô ¼º°ø",
                dwPartyID, dwCharID, dwReference);

            SendPacket::PartyCmd(PktDD::SCmdLogoutPartyMem, lpParty->GetPID(), dwCharID, dwReference, 0, 0, 0, 0);

	        if (0 == dwLeader)
	        {
                // ÆÄƼ ¸®´õ°¡ ¾ø¾î¼­ ÆÄƼ¸¦ ±ú¹ö¸³´Ï´Ù.
                if(CloseParty(DBComponent, dwPartyID))
                {
                    DETLOG3(g_Log, "ÆÄƼ ·Î±× : PID:%10u / CID:%10u / Leader:%10u / ÆÄƼ ¸â¹ö ·Î±×¾Æ¿ô : ÆÄƼ ¸®´õ°¡ ¾ø¾î¼­ ÆÄƼ¸¦ ´Ý½À´Ï´Ù.",
                        dwPartyID, dwCharID, dwLeader);
                }
            }
        }
    }
}

void CPartyDBMgr::SendToGameServerPartyData(CSendStream& SendStream)
{
	// ÆÄƼÁ¤º¸¸¦ º¸³»ÁØ´Ù. //]		
	PartyMap::iterator start	= m_PartyMap.begin();
	PartyMap::iterator end		= m_PartyMap.end();

	for(; start!=end; ++start)
	{
		// ÆÄƼ Á¤º¸°¡ ÀÖÀ¸¸é º¸³»ÁØ´Ù //
		CPartyDBInfo* lpPartyDBInfo = start->second;

		if(lpPartyDBInfo)
		{
			// ÆÄƼ Á¤º¸¸¦ º¸³½´Ù //

			PARTY sParty = lpPartyDBInfo->GetParty();
			
			char* lpBuffer = SendStream.GetBuffer(sizeof(PktPIDAck));

			PktPIDAck* lppktPIDAck = reinterpret_cast<PktPIDAck*>(lpBuffer);

			memset(lppktPIDAck, 0, sizeof(PktPIDAck));

			lppktPIDAck->m_wCmd		= PktDD::SCmdGetPartyInfo;
			lppktPIDAck->m_Party	= lpPartyDBInfo->GetParty();

			SendStream.WrapHeader(sizeof(PktPIDAck), CmdAgentParty, 0, PktPMD::NO_SERVER_ERR);

			// ÆÄƼ¿ø Á¤º¸¸¦ º¸³½´Ù //
			PARTY_USERINFO sPartyUserInfo = lpPartyDBInfo->GetPartyUserInfo();

			for(unsigned char cIndex = 0; cIndex < PARTY::MAX_MEM; cIndex++)
			{
				// ´Ù¸¥ °ÔÀÓ ¼­¹ö¿¡ Á¢¼ÓµÇ¾îÀִ ij¸¯ÅÍ //
				if(sParty.MemberCID[cIndex] && sParty.ServerID[cIndex])
				{
					char* lpBuffer = SendStream.GetBuffer(sizeof(PktPMD));

					if(0 != lpBuffer)
					{
						PktPMD* lpPktPMD = reinterpret_cast<PktPMD*>(lpBuffer);

						lpPktPMD->m_wCmd            = PktDD::SCmdLoginPartyMem;
						lpPktPMD->m_dwPartyID       = sParty.m_dwPartyID;
						lpPktPMD->m_dwSenderID      = sParty.MemberCID[cIndex];
						lpPktPMD->m_dwGID			= sPartyUserInfo.m_dwGID[cIndex];
						lpPktPMD->m_wClass			= sParty.m_wClass[cIndex];
						lpPktPMD->m_dwServerID		= sParty.ServerID[cIndex];
						lpPktPMD->m_cLevel			= sParty.m_cLevel[cIndex];

						if(sParty.Name[cIndex])
						{
							strncpy(lpPktPMD->m_strSenderName, sParty.Name[cIndex], CHAR_INFOST::MAX_NAME_LEN);
							lpPktPMD->m_strSenderName[CHAR_INFOST::MAX_NAME_LEN - 1] = 0;
						}
						else
						{
							memset(lpPktPMD->m_strSenderName, 0, sizeof(char) * CHAR_INFOST::MAX_NAME_LEN);
						}

						SendStream.WrapHeader(sizeof(PktPMD), CmdAgentParty, 0, PktPMD::NO_SERVER_ERR);
					}					
				}
			}
		}
	}
}
}