#include "stdafx.h"
#include "DNGuildVillage.h"
#include "DNMasterConnection.h"
#include "DNGameDataManager.h"
#include "DNSchedule.h"
#include "DNGuildWarManager.h"

CDNGuildVillage::CDNGuildVillage() 
{
	m_GuildWare = NULL;
	m_nResetWareHour = 4;
	GuildWarReset();	
};

CDNGuildVillage::~CDNGuildVillage() 
{

};

void CDNGuildVillage::Reset()
{
	if (m_GuildWare)
		m_GuildWare->ReportWareSlot();

	CDNGuildBase::Reset ();
	GuildWarReset();

	SAFE_DELETE(m_GuildWare);	
}

void CDNGuildVillage::OpenWare(const TAGetGuildWareInfo* pPacket)
{
	if (m_GuildWare == NULL)
		m_GuildWare = new CDNGuildWare();

	if (m_GuildWare)
		m_GuildWare->Open(this, pPacket);
	else
		_DANGER_POINT ();
}

// ±æµå¿øÀÎÁö È®ÀÎ
bool CDNGuildVillage::IsValiadMember(CDNUserSession *pUserObj, INT64 nCharacterDBID)
{
	if (!pUserObj || !pUserObj->GetGuildUID().IsSet() || GetUID() != pUserObj->GetGuildUID() || (nCharacterDBID != pUserObj->GetCharacterDBID()))
		return false;

	return true;
}

// ·Î±×ÀÎÇÑ ±æµå¿ø¿¡ ´ëÇØ Àüü¹ß¼Û
void CDNGuildVillage::SendGuildMemberLoginList(SCGuildMemberLoginList* pPacket)
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID (iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		pUserObj->SendGuildMemberLoginList(pPacket);
	}
}

// ±æµåÀÚ¿øÀ» È®ÀÎÇÑ´Ù.
bool CDNGuildVillage::CheckGuildResource(TGuildMember* pGuildMemeber)
{
	if (false == CDNGuildBase::CheckGuildResource(pGuildMemeber))
		return false;

	CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID (pGuildMemeber->nAccountDBID);

	// À¯Àú»óÅ ȮÀÎ
	if (pUserObj && pUserObj->GetGuildUID().IsSet())
	{
		// ±æµåÁ¤º¸ È®ÀÎ
		// »ç¿ëÀÚ ¼¼¼ÇÆ÷ÀÎÅ͸¦ ¾ò¾îµµ µ¿±âÈ­ º¸ÀåµÇÁö ¾ÊÀ¸¹Ç·Î È®Àο뵵·Î¸¸ »ç¿ëÇÒ°Í!
		if (GetUID() == pUserObj->GetGuildUID() && (pGuildMemeber->nCharacterDBID == pUserObj->GetCharacterDBID()))
			return false;
	}

	// ¸â¹ö¸®½ºÆ®¸¦ °è¼Ó Á¶È¸ÇÑ´Ù
	return true;
}

void CDNGuildVillage::SendAddGuildMember(UINT nAccountDBID, INT64 nCharacterDBID, LPCWSTR lpwszCharacterName, TP_JOB nJob, char cLevel, __time64_t pJoinDate, TCommunityLocation* pLocation)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		pUserObj->SendInviteGuildMemberAck (nAccountDBID, nCharacterDBID, lpwszCharacterName, ERROR_NONE, 0, 0, nJob, cLevel, pLocation, &GetUID());
	}
}

void CDNGuildVillage::SendDelGuildMember(UINT nAccountDBID, INT64 nCharacterDBID, bool bIsExiled)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		// ¿ì½Â ±æµåÀÎÁö È®ÀÎ
		if( pUserObj && g_pGuildWarManager && g_pGuildWarManager->GetPreWinGuildUID().IsSet() 
			&& GetUID() == g_pGuildWarManager->GetPreWinGuildUID() && nAccountDBID == pUserObj->GetAccountDBID() )
			pUserObj->SendGuildWarPreWinGuild(false);
		
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		if( nCharacterDBID == pUserObj->GetCharacterDBID() )
		{

			pUserObj->GetItem()->RemoveGuildReversionItem( true );
			pUserObj->GetItem()->RemoveGuildReversionVehicleItemData( true );
			pUserObj->SendGuildRewardItem(NULL);
		}
		if (bIsExiled)
			pUserObj->SendExileGuildMember(nAccountDBID, nCharacterDBID, ERROR_NONE, &GetUID());
		else
			pUserObj->SendLeaveGuildMember(nAccountDBID, nCharacterDBID, ERROR_NONE, &GetUID(), false);
	}
}

void CDNGuildVillage::SendChangeGuildInfo(UINT nAccountDBID, INT64 nCharacterDBID, BYTE btGuildUpdate, int iInt1, int iInt2, int iInt3, int iInt4, INT64 biInt64, LPCWSTR pText)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendChangeGuildInfoEx(nAccountDBID, nCharacterDBID, btGuildUpdate, ERROR_NONE, iInt1, iInt2, iInt3, iInt4, biInt64, pText, &GetUID());
	}
}

void CDNGuildVillage::SendChangeGuildMemberInfo(UINT nReqAccountDBID, INT64 nReqCharacterDBID, UINT nChgAccountDBID, INT64 nChgCharacterDBID, BYTE btGuildMemberUpdate, int iInt1, int iInt2, INT64 biInt64, LPCWSTR pText)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID (iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendChangeGuildMemberInfo (nReqAccountDBID, nReqCharacterDBID, nChgAccountDBID, nChgCharacterDBID, btGuildMemberUpdate, ERROR_NONE, iInt1, iInt2, biInt64, pText, &GetUID());

		// [ÁÖÀÇ] ij¸¯ÅÍID±âÁØÀ¸·¯ ó¸®ÇØ¾ß ÇÔ.
		if (nChgCharacterDBID == pUserObj->GetCharacterDBID())
		{
			switch(btGuildMemberUpdate) 
			{
			case GUILDMEMBUPDATE_TYPE_ROLE: // Á÷±Þ º¯°æ
				{
					pUserObj->GetGuildSelfView().btGuildRole = static_cast<BYTE>(iInt1);

					// ±æµå ½Ã°¢Á¤º¸ °»½Å
					pUserObj->RefreshGuildSelfView();
				}
				break;
			
			case GUILDMEMBUPDATE_TYPE_GUILDMASTER: // ±æµåÀå À§ÀÓ
				{
					pUserObj->GetGuildSelfView().btGuildRole = static_cast<BYTE>(GUILDROLE_TYPE_MASTER);

					// ±æµå ½Ã°¢Á¤º¸ °»½Å
					pUserObj->RefreshGuildSelfView();
				}
				break;
			default:
				break;
			}
		}
	}
}

void CDNGuildVillage::SendGuildChat(UINT nAccountDBID, INT64 nCharacterDBID, LPCWSTR lpwszChatMsg, short nLen)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList(List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		pUserObj->SendGuildChat(GetUID(), nAccountDBID, nCharacterDBID, lpwszChatMsg, nLen);
	}
}

#ifdef PRE_ADD_DOORS_GUILDCHAT_DISCONNECT
void CDNGuildVillage::SendDoorsGuildChat(INT64 nCharacterDBID, LPCWSTR lpwszChatMsg, short nLen)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList(List);

	if (List.empty())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();
	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendDoorsGuildChat(GetUID(), nCharacterDBID, lpwszChatMsg, nLen);
	}
}
#endif		//#ifdef PRE_ADD_DOORS_GUILDCHAT_DISCONNECT

void CDNGuildVillage::SendChangeGuildName(const wchar_t* wszGuildName)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		pUserObj->SendChangeGuildName(wszGuildName);
		_wcscpy( pUserObj->GetGuildSelfView().wszGuildName, _countof(pUserObj->GetGuildSelfView().wszGuildName), wszGuildName, (int)wcslen(wszGuildName) );
		pUserObj->RefreshGuildSelfView();
	}
}

void CDNGuildVillage::SendChangeGuildMark(const MAGuildChangeMark *pPacket)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");
	DN_ASSERT(!IsLock(),	"Already Locked!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		pUserObj->SendChangeGuildMark(pPacket);
		pUserObj->GetGuildSelfView().wGuildMark = pPacket->wMark;
		pUserObj->GetGuildSelfView().wGuildMarkBG = pPacket->wMarkBG;
		pUserObj->GetGuildSelfView().wGuildMarkBorder = pPacket->wMarkBorder;
		pUserObj->RefreshGuildSelfView();
	}
}

void CDNGuildVillage::SendExtendGuildWare(short wTotalSize)
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendExtendGuildWare(wTotalSize);
	}
}

void CDNGuildVillage::SendGuildLevelUp (int nLevel)
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		pUserObj->SendGuildLevelUp(nLevel);
	}
}

void CDNGuildVillage::SendUpdateGuildExp(BYTE cPointType, int nPointValue, int nGuildExp, INT64 biCharacterDBID, int nMissionID)
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember (pUserObj, iter->second))
			continue;

		if (cPointType == GUILDPOINTTYPE_STAGE)
		{
			if (pUserObj->GetCharacterDBID() == biCharacterDBID)
			{
				pUserObj->SendUpdateGuildExp(ERROR_NONE, cPointType, nPointValue, nGuildExp, biCharacterDBID, nMissionID);
				break;
			}
		}
		else
			pUserObj->SendUpdateGuildExp(ERROR_NONE, cPointType, nPointValue, nGuildExp, biCharacterDBID, nMissionID);
	}
}

#ifdef PRE_ADD_JOINGUILD_SUPPORT
void CDNGuildVillage::SendRefreshGuildItem(char cType, INT64 biSrcSerial, INT64 biDestSerial, const TItemInfo *pSrcInfo, const TItemInfo *pDestInfo, CDNUserSession* pSession, bool bNoUpdate)
#else		//#ifdef PRE_ADD_JOINGUILD_SUPPORT
void CDNGuildVillage::SendRefreshGuildItem(char cType, INT64 biSrcSerial, INT64 biDestSerial, const TItemInfo *pSrcInfo, const TItemInfo *pDestInfo, CDNUserSession* pSession)
#endif		//#ifdef PRE_ADD_JOINGUILD_SUPPORT
{
	// ¸â¹ö°¡¾øÀ¸¸é¸®ÅÏ
	if (m_MapTotalMember.empty())
		return;

	// ±æµå°¡ ¾øÀ¸¸é ¸®ÅÏ
	if (!m_GuildWare)
		return;

	ScopeLock <CSyncLock> AutoLock (GetLock());

	std::map<INT64, TGuildMember>::iterator iter = m_MapTotalMember.begin ();

	for (; iter != m_MapTotalMember.end(); iter++)
	{
		TGuildMember* pGuildMember = &(iter->second);
	
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(pGuildMember->nAccountDBID);
		if (false == IsValiadMember (pUserObj, pGuildMember->nCharacterDBID))
			continue;

		if (pUserObj == pSession)
		{
			// ¿äûÀÚÀÎ ÀÚ±âÀڽſ¡°Ô´Â ¹öÁ¯¾÷µ¥ÀÌÆ® ÇÑ´Ù.
#ifdef PRE_ADD_JOINGUILD_SUPPORT
			if (bNoUpdate == true)
				continue;

			pGuildMember->WareVeriosnDate = m_GuildWare->GetVersionDate();
#else		//#ifdef PRE_ADD_JOINGUILD_SUPPORT
			pGuildMember->WareVeriosnDate = m_GuildWare->GetVersionDate();
#endif		//#ifdef PRE_ADD_JOINGUILD_SUPPORT
			continue;
		}

		// ±æµåâÀ» ¿­Áö ¾ÊÀº À¯Àú´Â ¹öÁ¯¾÷µ¥ÀÌÆ®¸¦ ÇÏÁö ¾Ê´Â´Ù.
		if (pGuildMember->bOpenWareStatus == false)
			continue;

		pGuildMember->WareVeriosnDate = m_GuildWare->GetVersionDate();

		pUserObj->SendRefreshGuildItem(cType, biSrcSerial, biDestSerial, pSrcInfo, pDestInfo);
	}
}

void CDNGuildVillage::SendRefreshGuildCoin(INT64 biTotalCoin, CDNUserSession* pSession)
{
	DN_ASSERT(IsOpen(),		"Not Opened!");
	DN_ASSERT(IsAttach(),	"Not Attached!");

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		if (pUserObj == pSession)
			continue;

		pUserObj->SendRefreshGuildCoin(biTotalCoin);
	}
}

void CDNGuildVillage::UpdateGuildInfo(CDNUserSession* pSession, const TAChangeGuildInfo *pPacket)
{
	switch(pPacket->btGuildUpdate) 
	{
	case GUILDUPDATE_TYPE_NOTICE:			// °øÁöº¯°æ
		{
			{
				ScopeLock <CSyncLock> AutoLock (GetLock());

				_wcscpy(SetInfo()->wszGuildNotice, _countof(GetInfo()->wszGuildNotice), pPacket->Text, (int)wcslen(pPacket->Text));
			}
		}
		break;

	case GUILDUPDATE_TYPE_ROLEAUTH:			// Á÷±Þ±ÇÇѺ¯°æ
		{
			SetInfo()->wGuildRoleAuth[pPacket->nInt1] = static_cast<int>(pPacket->nInt2);
			SetInfo()->nRoleMaxItem[pPacket->nInt1] = static_cast<int>(pPacket->nInt3);
			SetInfo()->nRoleMaxCoin[pPacket->nInt1] = static_cast<int>(pPacket->nInt4);
		}
		break;
#if defined( PRE_ADD_GUILD_EASYSYSTEM )
	case GUILDUPDATE_TYPE_HOMEPAGE:
		{
			{
				ScopeLock <CSyncLock> AutoLock (GetLock());
				_wcscpy(SetInfo()->wszGuildHomePage, _countof(GetInfo()->wszGuildHomePage), pPacket->Text, (int)wcslen(pPacket->Text));
			}			
		}
		break;
#endif
		

	
	default:
		{
			pSession->SendChangeGuildInfo(pPacket->nAccountDBID, pPacket->nCharacterDBID, pPacket->btGuildUpdate, ERROR_GENERIC_INVALIDREQUEST, pPacket->nInt1, pPacket->nInt2, pPacket->biInt64, pPacket->Text, NULL);
			return;
		}
		break;
	}

	// ÇöÀç¼­¹ö¿¡ Á¢¼ÓÁßÀÎ ±æµå¿øµé¿¡°Ô Å뺸
	SendChangeGuildInfo(pPacket->nAccountDBID, pPacket->nCharacterDBID, pPacket->btGuildUpdate, pPacket->nInt1, pPacket->nInt2, pPacket->nInt3, pPacket->nInt4, pPacket->biInt64, pPacket->Text);

	// MA ¸¦ÅëÇÏ¿© ´Ù¸¥¼­¹öÀÇ ±æµåÀϹÝÁ¤º¸µµ °»½ÅÇϵµ·Ï ÁöÁ¤
	if (g_pMasterConnection)
		g_pMasterConnection->SendChangeGuildInfo(GetUID(), pPacket->nAccountDBID, pPacket->nCharacterDBID, pPacket->btGuildUpdate, 
													pPacket->nInt1, pPacket->nInt2, pPacket->nInt3, pPacket->nInt4, pPacket->biInt64, pPacket->Text);
}

CDNGuildWare* CDNGuildVillage::GetGuildWare()
{
	return m_GuildWare;
}

void CDNGuildVillage::RecvCsCloseGuildWare(CDNUserSession * pSession)
{
	// â°í¸¦ óÀ½ ¿¬ »ç¶÷ÀÎÁö È®ÀÎÇÑ´Ù.
	TGuildMember* pGuildMember = GetMemberInfo(pSession->GetCharacterDBID());
	if (pGuildMember)
	{
		pGuildMember->bOpenWareStatus = false;
	}
}

void CDNGuildVillage::RecvApiOpenGuildWare(CDNUserSession * pSession)
{
	if (!m_GuildWare)
	{
		// ±æµåâ°í Á¤º¸°¡ ±¸¼ºµÇ¾î ÀÖÁö ¾ÊÀ¸¸é DB¿¡ Àç¿äûÇÑ´Ù.
		ReqGetGuildWareInfo();
		g_Log.Log(LogType::_ERROR, pSession, L"ReqGetGuildWareInfo[CDBID:%I64d][GuildDBID:%d][WorldSetID:%d]\r\n", pSession->GetCharacterDBID(), GetUID().nDBID, pSession->GetWorldSetID());
		return;
	}

	TGuildMember* pGuildMember = GetMemberInfo(pSession->GetCharacterDBID());
	if (!pGuildMember)
		return;

	// â°íÀÌ¿ë Ƚ¼ö ¸®¼ÂÀ» °Ë»çÇÑ´Ù.
	CheckResetWareLimit (pGuildMember);

	// â°í¸¦ óÀ½ ¿¬ »ç¶÷ÀÎÁö È®ÀÎÇÑ´Ù.
	if (pGuildMember->WareVeriosnDate != m_GuildWare->GetVersionDate())
		SendGuildWareList (pSession, 0);
	else 
		SendGuildWareList (pSession, 1);


	pGuildMember->WareVeriosnDate = m_GuildWare->GetVersionDate();
	pGuildMember->bOpenWareStatus = true;
}

void CDNGuildVillage::CheckResetWareLimit(TGuildMember* pGuildMember)
{
	if (!pGuildMember)
		return;

	if (pGuildMember->LastWareUseDate < 0)
		return;

	tm tLastTime = *localtime(&pGuildMember->LastWareUseDate);

	time_t tCurTime;
	time(&tCurTime);

	tm tCurWareTime = *localtime(&tCurTime);


	tm tResetTime;
	tResetTime = tCurWareTime;
	tResetTime.tm_hour = m_nResetWareHour;
	tResetTime.tm_min = 0;
	tResetTime.tm_sec = 0;

	if (tCurWareTime.tm_hour < m_nResetWareHour)
		tResetTime.tm_yday--;

	if (tLastTime.tm_yday < tResetTime.tm_yday)
	{
		pGuildMember->TakeWareItemCount = 0;
		pGuildMember->WithdrawCoin = 0;	
	}
	else if (tLastTime.tm_yday == tResetTime.tm_yday && tLastTime.tm_hour < tResetTime.tm_hour)
	{
		pGuildMember->TakeWareItemCount = 0;
		pGuildMember->WithdrawCoin = 0;	
	}
}

void CDNGuildVillage::RecvCsGetGuildWareHistory(CDNUserSession * pSession, CSGetGuildWareHistory *pPacket)
{
	if (m_GuildWare)
		m_GuildWare->OnRecvGetWareHistory(pSession, pPacket);
}

void CDNGuildVillage::RecvMaRefreshGuildItem(MARefreshGuildItem* pPacket)
{
	if (!m_GuildWare)
		return; // ±æµåâ°í°¡ »ý¼ºµÇ±â Àü¿¡ ´Ù¸¥ ¼­¹ö¿¡¼­ Á¤º¸°¡ µé¾î¿Ã ¼ö ÀÖÀ¸¹Ç·Î ¸®ÅÏ

	switch (pPacket->cMoveType)
	{
		case MoveType_GuildWare:
		{
			// ºóÄ­À̵¿
			if (pPacket->biDestSerial == 0)
				m_GuildWare->UpdateWareInfo(pPacket->DestInfo);
			else // ÇÕº´ÇÏ´Â ÄÉÀ̽º
			{
				m_GuildWare->RemoveWareItem(pPacket->biDestSerial);
				m_GuildWare->AddWareItemInfo(pPacket->DestInfo);
			}
		}
		break;

		case MoveType_InvenToGuildWare:
		{
			// ºóÄ­À̵¿
			if (pPacket->biDestSerial == 0)
				m_GuildWare->UpdateWareInfo(pPacket->DestInfo);
			else // ÇÕº´ÇÏ´Â ÄÉÀ̽º
			{
				m_GuildWare->RemoveWareItem(pPacket->biDestSerial);
				m_GuildWare->AddWareItemInfo(pPacket->DestInfo);
			}			
		}	
		break;

		case MoveType_GuildWareToInven:
		{
			m_GuildWare->UpdateWareInfo (pPacket->SrcInfo);
		}
		break;

#ifdef PRE_ADD_JOINGUILD_SUPPORT
		case MoveType_MailToGuildWare:
		{
			m_GuildWare->AddWareItemInfo(pPacket->DestInfo);
		}
		break;
#endif		//#ifdef PRE_ADD_JOINGUILD_SUPPORT
	}

	// ¹öÁ¯À» ¼³Á¤ÇÑ´Ù.
	m_GuildWare->SetVersionDate(pPacket->VersionDate);

	// ±æµå¿øµé¿¡°ÔÁ¤º¸¸¦¾Ë·ÁÁØ´Ù.
	SendRefreshGuildItem (pPacket->cMoveType, pPacket->biSrcSerial, pPacket->biDestSerial, &pPacket->SrcInfo, &pPacket->DestInfo);
}

void CDNGuildVillage::RecvMaRefreshGuildCoin(MARefreshGuildCoin* pPacket)
{
	SetInfo()->ui64GuildMoney = pPacket->biTotalCoin;

	SendRefreshGuildCoin (pPacket->biTotalCoin);
}
void CDNGuildVillage::UpdateMemberInfo(CDNUserSession* pSession, const TAChangeGuildMemberInfo *pPacket)
{
	DN_ASSERT(IsOpen(),								"Not Opened!");
	DN_ASSERT(IsAttach(),							"Not Attached!");
	DN_ASSERT(0 != pPacket->nReqCharacterDBID,	"Invalid!");

	switch (pPacket->btGuildMemberUpdate)
	{

		// ÀÚ±â¼Ò°³ º¯°æ (±æµå¿øÀÚ½Å)
	case GUILDMEMBUPDATE_TYPE_INTRODUCE:	
		ModifyMembIntro(pSession, pPacket);
		break;

		// Á÷±Þº¯°æ
	case GUILDMEMBUPDATE_TYPE_ROLE:			
		ModifyMembRole(pSession, pPacket);
		break;

		// ±æµåÀå À§ÀÓ
	case GUILDMEMBUPDATE_TYPE_GUILDMASTER:  
		ChangeGuildMaster(pSession, pPacket);
		break;

		// ÀϹÝÆ÷ÀÎÆ®Áõ°¡/°¨¼Ò(±â¿©ºÐ)
	case GUILDMEMBUPDATE_TYPE_CMMPOINT:		
		ApplyGuildPoint(pSession, pPacket);
		break;

		// ³ª¸ÓÁö´Â ¿¡·¯Ã³¸®!
	default:	
		pSession->SendChangeGuildMemberInfo(pPacket->nReqAccountDBID, pPacket->nReqCharacterDBID, pPacket->nChgAccountDBID, pPacket->nChgCharacterDBID, pPacket->btGuildMemberUpdate, 
			ERROR_GENERIC_INVALIDREQUEST, pPacket->nInt1, pPacket->nInt2, pPacket->biInt64, pPacket->Text, NULL);
		break;
	}

	// ÇöÀç¼­¹ö¿¡Á¢¼ÓÁßÀαæµå¿øµé¿¡°ÔÅ뺸
	SendChangeGuildMemberInfo(pPacket->nReqAccountDBID, pPacket->nReqCharacterDBID, pPacket->nChgAccountDBID, pPacket->nChgCharacterDBID, pPacket->btGuildMemberUpdate, pPacket->nInt1, pPacket->nInt2, pPacket->biInt64, pPacket->Text);

	// MA ¸¦ÅëÇÏ¿©´Ù¸¥¼­¹ö¿¡Á¢¼ÓÁßÀαæµå¿øµé¿¡°ÔµµÅ뺸
	if (g_pMasterConnection)
		g_pMasterConnection->SendChangeGuildMemberInfo(GetUID(), pPacket->nReqAccountDBID, pPacket->nReqCharacterDBID, pPacket->nChgAccountDBID, pPacket->nChgCharacterDBID, pPacket->btGuildMemberUpdate, pPacket->nInt1, pPacket->nInt2, pPacket->biInt64, pPacket->Text);
}

void CDNGuildVillage::GuildWarReset()
{
	CDNGuildBase::GuildWarReset();
	m_bGuildWarStats = false;
	m_nGuildWarPoint = 0;
	memset(&m_sMyGuildWarRankingInfo, 0, sizeof(m_sMyGuildWarRankingInfo));
	memset(&m_sMyGuildWarMissionGuildRankingInfo, 0, sizeof(m_sMyGuildWarMissionGuildRankingInfo));
}

void CDNGuildVillage::UpdateWarInfoOnAllMember(short wScheduleID, BYTE cTeamColorCode)
{
	if (g_pGuildWarManager && g_pGuildWarManager->GetScheduleID() != wScheduleID)
		return;

	m_Info.GuildView.wWarSchduleID = wScheduleID;
	m_Info.GuildView.cTeamColorCode = cTeamColorCode;

	ScopeLock <CSyncLock> AutoLock (GetLock());

	std::map<INT64, TGuildMember>::iterator iter = m_MapTotalMember.begin ();

	for (; iter != m_MapTotalMember.end(); iter++)
	{
		TGuildMember* pGuildMember = &(iter->second);

		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(pGuildMember->nAccountDBID);
		if (false == IsValiadMember (pUserObj, pGuildMember->nCharacterDBID))
			continue;

		pUserObj->GetGuildSelfView().wWarSchduleID = wScheduleID;
		pUserObj->GetGuildSelfView().cTeamColorCode = cTeamColorCode;
		pUserObj->RefreshGuildSelfView();

		// °¢ À¯Àú¿¡°Ô ±æµåÀü¿¡ ½ÅûÀ» ¾Ë¸°´Ù.
		pUserObj->SendEnrollGuildWar(ERROR_NONE, wScheduleID, cTeamColorCode);
	}
}

void CDNGuildVillage::SendGuildWarPreWinGuild(bool bPreWin)
{
	ScopeLock <CSyncLock> AutoLock (GetLock());

	std::map<INT64, TGuildMember>::iterator iter = m_MapTotalMember.begin ();

	for (; iter != m_MapTotalMember.end(); iter++)
	{
		TGuildMember* pGuildMember = &(iter->second);

		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID (pGuildMember->nAccountDBID);
		if (false == IsValiadMember (pUserObj, pGuildMember->nCharacterDBID))
			continue;		

		// °¢ À¯Àú¿¡°Ô ±æµåÀü ¿ì½ÂÀ» ¾Ë¸².
		pUserObj->SendGuildWarPreWinGuild(bPreWin);
	}
}

void CDNGuildVillage::SetGuildWarMyRankingInfo(TAGetGuildWarPointGuildTotal* pGetGuildWarPointGuildTotal )
{	
	m_sMyGuildWarRankingInfo.wRanking = pGetGuildWarPointGuildTotal->sGuildWarPointGuildTotal[0].wRanking;
	m_sMyGuildWarRankingInfo.nTotalPoint = pGetGuildWarPointGuildTotal->sGuildWarPointGuildTotal[0].nOpeningPointSum;
}

void CDNGuildVillage::SetGuildWarTotalRankingInfo(TAGetGuildWarPointGuildPartTotal* pGetGuildWarPointGuildPartTotal )
{
	for( int i=0; i<GUILDWAR_RANKINGTYPE_MAX; ++i)
	{
		m_sMyGuildWarMissionGuildRankingInfo[i].wRanking = pGetGuildWarPointGuildPartTotal->GuildWarPointPartTotal[i].wRanking;
		m_sMyGuildWarMissionGuildRankingInfo[i].nTotalPoint = pGetGuildWarPointGuildPartTotal->GuildWarPointPartTotal[i].nPoint;
	}
	m_bGuildWarStats = true;
}
// ±æµå ¿¹¼±Àü ±æµå Æ÷ÀÎÆ® °ø½Ä
int	CDNGuildVillage::CalcGuildWarTrialPoint()
{
	//±æµå°¡ ȹµæÇÑ ¹Ì¼Ç Æ÷ÀÎÆ® + ( ±æµå°¡ ȹµæÇÑ ¹Ì¼Ç Æ÷ÀÎÆ® * ±æµå¿¡¼­ ¼ö»óÇÑ Æ¯º°»ó ÃÑ °³¼ö * 0.1)
	return (int)(m_nGuildWarPoint+(m_nGuildWarPoint*g_pGuildWarManager->GetGuildAwardCount(GetUID().nDBID)*0.1f));
}

void CDNGuildVillage::ReqGetGuildWareInfo(bool bForceReq)
{
	if (bForceReq == false)
	{
		if (m_GuildWare)
			return;
	}

	// ±æµåâ°í¿äû
	if (m_pDBCon)
		m_pDBCon->QueryGetGuildWareInfo(m_cDBThreadID, GetUID().nDBID, GetUID().nWorldID, GetWareSize());
	
}

void CDNGuildVillage::UpdateWareSize(CDNUserBase* pUserObject, short wSize)
{
	SetInfo()->wGuildWareSize = wSize;

	if (m_GuildWare)
		m_GuildWare->ChangeWareSize(pUserObject, wSize);
	else
		_ASSERT(0);
}

void CDNGuildVillage::SendGuildRewardItem( TGuildRewardItem* GuildRewardItem )
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendGuildRewardItem(GuildRewardItem);
	}
}
void CDNGuildVillage::SendAddGuildRewardItem( TGuildRewardItem GuildRewardItem )
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendAddGuildRewardItem(GuildRewardItem);
	}
}
void CDNGuildVillage::SendExtendGuildSize(short nGuildSize)
{
	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>> List;
	GetMemberList (List);

	if (List.empty ())
		return;

	std::vector <std::pair<UINT, INT64>, boost::pool_allocator<UINT>>::iterator iter = List.begin ();

	for (; iter != List.end (); iter++)
	{
		CDNUserSession *pUserObj = g_pUserSessionManager->FindUserSessionByAccountDBID(iter->first);
		if (false == IsValiadMember(pUserObj, iter->second))
			continue;

		pUserObj->SendExtendGuildSize(nGuildSize);
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////						PRIVATE FUNCTION
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void CDNGuildVillage::SendGuildWareList(CDNUserSession * pSession, int nResult)
{
	SCOpenGuildWare Packet;
	memset (&Packet, 0x00, sizeof(Packet));

	Packet.nError = ERROR_NONE;
	Packet.nResult = nResult;
	Packet.wWareSize = GetWareSize();

	int nSize = sizeof(Packet.nError) + sizeof (Packet.nResult) + sizeof(Packet.wWareSize);
	
	if (!m_GuildWare)
		Packet.nError = ERROR_GUILDWARE_NOT_READY;
	else
	{

		TGuildMember* pGuildMember = GetMemberInfo(pSession->GetCharacterDBID());
		if (pGuildMember)
		{
			Packet.nTakeWareItemCount = pGuildMember->TakeWareItemCount;
			Packet.nWithdrawCoin = pGuildMember->WithdrawCoin;

			nSize += sizeof(Packet.nTakeWareItemCount) + sizeof(Packet.nWithdrawCoin);
		
			if (GetWareSize() <= 0)
				Packet.nError = ERROR_GUILDWARE_NOT_READY;
			else
			{

				Packet.nGuildCoin = m_GuildWare->GetWarehouseCoin();
				nSize += sizeof(Packet.nGuildCoin);

				if (nResult == 0)
				{				
					Packet.VersionDate = m_GuildWare->GetVersionDate();
					nSize += sizeof(Packet.VersionDate);

					Packet.cWareCount = m_GuildWare->GetWareList (Packet.WareList);
					nSize += (sizeof(TItemInfo)*Packet.cWareCount) + sizeof(Packet.cWareCount);
					
				}
			}
			
		}
		else
			Packet.nError = ERROR_GUILD_YOUR_NOT_BELONGANYGUILD;
			
	}

	pSession->AddSendData (SC_GUILD, eGuild::SC_OPEN_GUILDWARE, (char*)&Packet, nSize);
}

// ±æµå¿ø ÀÚ±â¼Ò°³¸¦ ¼öÁ¤ÇÑ´Ù
void CDNGuildVillage::ModifyMembIntro(CDNUserSession* pSession, const TAChangeGuildMemberInfo *pPacket)
{
	{
		ScopeLock <CSyncLock> AutoLock (GetLock());

		TGuildMember* pGuildMember = GetMemberInfoAsync(pPacket->nReqCharacterDBID);
		if (pGuildMember)
			_wcscpy(pGuildMember->wszGuildMemberIntroduce, _countof(pGuildMember->wszGuildMemberIntroduce), pPacket->Text, (int)wcslen(pPacket->Text));
	}

	USES_CONVERSION;
}

// ±æµå¿ø Á÷±ÞÀ» º¯°æÇÑ´Ù.
void CDNGuildVillage::ModifyMembRole(CDNUserSession* pSession, const TAChangeGuildMemberInfo *pPacket)
{
	ScopeLock <CSyncLock> AutoLock (GetLock());

	TGuildMember* pGuildMember = GetMemberInfoAsync(pPacket->nChgCharacterDBID);

	if (!pGuildMember)
		return;

	// Á÷±Þº¯°æ
	pGuildMember->btGuildRole = static_cast<BYTE>(pPacket->nInt1);
}

// ±æµåÀåÀ» À§ÀÓÇÑ´Ù.
void CDNGuildVillage::ChangeGuildMaster(CDNUserSession* pSession, const TAChangeGuildMemberInfo *pPacket)
{
	WCHAR aCharacterName[NAMELENMAX] = { L'\0', };
	TGuildMember* pGuildMember = NULL;
	{
		ScopeLock <CSyncLock> AutoLock (GetLock());

		pGuildMember = GetMemberInfoAsync (pPacket->nChgCharacterDBID);

		// ¸¶½ºÅÍ·Î ·Ñ º¯°æ
		if (pGuildMember)
		{
			pGuildMember->btGuildRole = static_cast<BYTE>(GUILDROLE_TYPE_MASTER);
			_wcscpy(aCharacterName, _countof(aCharacterName), pGuildMember->wszCharacterName, (int)wcslen(pGuildMember->wszCharacterName));
			SetGuildMaster( pGuildMember );
		}

		pGuildMember = GetMemberInfoAsync(pPacket->nReqCharacterDBID);

		// ¸¶½ºÅÍ->ºÎ¸¶½ºÅÍ (º¯°æ)
		if (pGuildMember)
			pGuildMember->btGuildRole = static_cast<BYTE>(GUILDROLE_TYPE_SUBMASTER);	

	}

	// °³Àμ¼¼Ç Á¤º¸ º¯°æ
	pSession->GetGuildSelfView().btGuildRole = static_cast<BYTE>(GUILDROLE_TYPE_SUBMASTER);

	// ±æµå½Ã°¢Á¤º¸°»½Å
	pSession->RefreshGuildSelfView();

	USES_CONVERSION;
}

// ±æµåÆ÷ÀÎÅ͸¦ Àû¿ëÇÑ´Ù
void CDNGuildVillage::ApplyGuildPoint(CDNUserSession* pSession, const TAChangeGuildMemberInfo *pPacket)
{
	ScopeLock <CSyncLock> AutoLock (GetLock());

	TGuildMember* pGuildMember = GetMemberInfoAsync(pPacket->nReqCharacterDBID);

	if (pGuildMember)
	{
		pGuildMember->iUseGuildCommonPoint = static_cast<long>(pPacket->nInt1);
		pGuildMember->iTotGuildCommonPoint = static_cast<long>(pPacket->nInt2);
	}
}