#include "StdAfx.h"
#include "DnBubbleEventHandler.h"
#include "DnObserverEventMessage.h"
#include "DnBubbleSystem.h"
#include "DnPlayerActor.h"
#include "DnBlow.h"
#include "DnTableDB.h"

namespace BubbleSystem
{

IDnBubbleEventHandler* IDnBubbleEventHandler::Create( int iEventHandlerType, DnActorHandle hActor, const char* pArgument )
{
	IDnBubbleEventHandler* pEventHandler = NULL;

	switch( iEventHandlerType )
	{
		case GETTING_BUBBLE:
			pEventHandler = new CDnGettingBubbleHandler;
			break;

		case REMOVE_BUBBLE:
			pEventHandler = new CDnRemoveBubbleHandler;
			break;

		case UPDATE_BUBBLE_STATE_EFFECT:
			pEventHandler = new CDnUpdateStateEffectHandler;
			break;

		case ENCHANT_SKILL_ONCE:
			pEventHandler = new CDnEnchantSkillOnce;
			break;

		default:
			return NULL;
	}

	pEventHandler->Initialize( hActor, pArgument );

	return pEventHandler;
}

// CDnGettingBubbleHandler
void CDnGettingBubbleHandler::Initialize( DnActorHandle hActor, const char* pArgument )
{
	if( !hActor || NULL == pArgument )
		return;

	m_hActor = hActor;

	std::vector<string> vlTokens;
	string strArgument( pArgument );
	TokenizeA( strArgument, vlTokens, ";" );

	_ASSERT( 2 == (int)vlTokens.size() );

	m_iBubbleTypeID = atoi( vlTokens.at(0).c_str() );
	m_fDurationTime = (float)(atoi( vlTokens.at(1).c_str() )) / 1000.0f;

	// ¹öºí ÃÖ´ë °¹¼ö¸¦ ³Ñ¾î°£´Ù¸é ´õ ÀÌ»ó ¹öºíÀ» ½×Áö ¾Êµµ·Ï ÇÑ´Ù.
	m_iAllowedMaxBubbleCount = 0;
	DNTableFileFormat* pBubbleDefineTable = GetDNTable( CDnTableDB::TSKILLBUBBLEDEFINE );
	if( pBubbleDefineTable->IsExistItem( m_iBubbleTypeID ) )
	{
		m_iAllowedMaxBubbleCount = pBubbleDefineTable->GetFieldFromLablePtr( m_iBubbleTypeID, "_BubbleLimit" )->GetInteger();
	}
}

void CDnGettingBubbleHandler::ProcessEvent( CDnBubbleSystem* pBubbleSystem, ::IDnObserverNotifyEvent* pEvent )
{
	// ÃÖ´ë ¹öºí °¹¼ö°¡ ³Ñ¾î°¡¸é Ãß°¡ÇÏÁö ¾Ê´Â´Ù.
	int iNowBubbleCount = pBubbleSystem->GetBubbleCountByTypeID( m_iBubbleTypeID );
	if( iNowBubbleCount < m_iAllowedMaxBubbleCount )
	{
		CDnBubbleSystem::S_CREATE_BUBBLE Info;
		Info.iBubbleTypeID = m_iBubbleTypeID;
		Info.iIconIndex = m_iIconIndex;
		Info.fDurationTime = m_fDurationTime;
		pBubbleSystem->AddBubble( Info );

		int iAddedBubbleCount = pBubbleSystem->GetBubbleCountByTypeID( m_iBubbleTypeID );

		// Ŭ¶óÀ̾ðÆ®·Î ¹öºí Ãß°¡ ÆÐŶ º¸³»ÁÜ.
		if( m_hActor )
		{
			// ¾ÆÀÌÄÜ À妽º°¡ ¼ÂÆÃµÈ ÈÄ¿¡ ÆÐŶÀ» ¸¸µé¾îµÐ´Ù.
			char acBuffer[ 32 ] = { 0 };
			CPacketCompressStream Stream( acBuffer, 32 );
			Stream.Write( &m_iBubbleTypeID, sizeof(m_iBubbleTypeID) );
			Stream.Write( &m_iIconIndex, sizeof(m_iIconIndex) );
			Stream.Write( &m_fDurationTime, sizeof(m_fDurationTime) );
			Stream.Write( &iAddedBubbleCount, sizeof(iNowBubbleCount) );

			m_hActor->Send( eActor::SC_ADDBUBBLE, &Stream );
		}
	}
	else
	{
		// ÃÖ´ë ¹öºí °¹¼ö°¡ ³Ñ¾î°¬À¸¹Ç·Î ±âÁ¸¿¡ ÀÖ´Â ¹öºíµéÀÇ Áö¼Ó½Ã°£¸¸ °»½ÅÇØÁØ´Ù.
		if( 0 < pBubbleSystem->GetBubbleCountByTypeID( m_iBubbleTypeID ) )
		{
			// Áö¼Ó½Ã°£ °»½Å.
			pBubbleSystem->SetDurationTime( m_iBubbleTypeID, m_fDurationTime );
			
			char acBuffer[ 32 ] = { 0 };
			CPacketCompressStream Stream( acBuffer, 32 );
			Stream.Write( &m_iBubbleTypeID, sizeof(int) );
			Stream.Write( &m_iIconIndex, sizeof(m_iIconIndex) );
			Stream.Write( &m_fDurationTime, sizeof(float) );
			Stream.Write( &iNowBubbleCount, sizeof(int) );

			m_hActor->Send( eActor::SC_REFRESH_BUBBLE_DURATIONTIME, &Stream );
		}
	}
}
//////////////////////////////////////////////////////////////////////////


// CDnRemoveBubbleHandler
void CDnRemoveBubbleHandler::Initialize( DnActorHandle hActor, const char* pArgument )
{
	if( !hActor || NULL == pArgument )
		return;

	m_hActor = hActor;

	std::vector<string> vlTokens;
	string strArgument( pArgument );
	TokenizeA( strArgument, vlTokens, ";" );

	_ASSERT( 2 == (int)vlTokens.size() );

	m_iBubbleTypeID = atoi( vlTokens.at(0).c_str() );
	m_iRemoveCount = atoi( vlTokens.at(1).c_str() );

	SecureZeroMemory( &m_PacketBuffer, sizeof(m_PacketBuffer) );
	m_pPacketStream.reset( new CPacketCompressStream( &m_PacketBuffer, sizeof(m_PacketBuffer) ) );
	m_pPacketStream->Write( &m_iBubbleTypeID, sizeof(m_iBubbleTypeID) );
	m_pPacketStream->Write( &m_iRemoveCount, sizeof(m_iRemoveCount) );
}

void CDnRemoveBubbleHandler::ProcessEvent( CDnBubbleSystem* pBubbleSystem, ::IDnObserverNotifyEvent* pEvent )
{
	pBubbleSystem->RemoveBubbleByTypeID( m_iBubbleTypeID, m_iRemoveCount );

	// Ŭ¶óÀ̾ðÆ®·Î ¹öºí Á¦°Å ÆÐŶ º¸³»ÁÜ.
	if( m_hActor )
	{
		m_hActor->Send( eActor::SC_REMOVEBUBBLE, m_pPacketStream.get() );
	}
}
//////////////////////////////////////////////////////////////////////////

// CDnUpdateStateEffectHandler
void CDnUpdateStateEffectHandler::Initialize( DnActorHandle hActor, const char* pArgument )
{
	if( !hActor || NULL == pArgument )
		return;

	m_hActor = hActor;

	std::vector<string> vlTokens;
	string strArgument( pArgument );
	TokenizeA( strArgument, vlTokens, ";" );

	_ASSERT( 2 == (int)vlTokens.size() );

	m_iBubbleTypeID = atoi( vlTokens.at(0).c_str() );
	m_iSkillID = atoi( vlTokens.at(1).c_str() );
}

void CDnUpdateStateEffectHandler::ProcessEvent( CDnBubbleSystem* pBubbleSystem, ::IDnObserverNotifyEvent* /*pEvent*/ )
{
	// ±âÁ¸¿¡ Á¸ÀçÇÏ´Â ¹öºí »óÅÂÈ¿°ú°¡ ÀÖ´Ù¸é »èÁ¦
	pBubbleSystem->RemoveBubbleStateBlow( m_iBubbleTypeID );

	// ¹öºí °¹¼ö¿¡ µû¶ó ·¹º§¸µÀ» ÇØÁØ´Ù.
	int iLevel = pBubbleSystem->GetBubbleCountByTypeID( m_iBubbleTypeID );
	m_hSkill = CDnSkill::CreateSkill( m_hActor, m_iSkillID, iLevel );

	// ½ºÅ³ »ý¼º ½ÇÆÐ. µ¥ÀÌÅÍ°¡ ¾ø°Å³ª À߸øµÈ °æ¿ì. pvp/pve ¸ðµÎ µ¥ÀÌÅÍ°¡ ÀÖ¾î¾ß ÇÑ´Ù.
	if( !m_hSkill )
		return;

	int iNumStateEffect = m_hSkill->GetStateEffectCount();
	for( int iSE = 0; iSE < iNumStateEffect; ++iSE )
	{
		const CDnSkill::StateEffectStruct* pSE = m_hSkill->GetStateEffectFromIndex( iSE );
		if( CDnSkill::ApplySelf == pSE->ApplyType )
		{
			// »óÅÂÈ¿°ú Ãß°¡ ÆÐŶ. ¿©±â¼­ Ãß°¡µÈ »óÅÂÈ¿°úÀÇ »èÁ¦´Â CDnBubbleSystem ÂÊ¿¡¼­
			// ó¸®ÇÑ´Ù. ¸ð¾ç»õ°¡ ¾ÈÁÁ±äÇÏÁö¸¸ ÀÏ´ÜÀº..
			int iBlowID = m_hActor->CmdAddStateEffect( NULL, (STATE_BLOW::emBLOW_INDEX)pSE->nID, -1, pSE->szValue.c_str() );
			_ASSERT( -1 != iBlowID );
			if( -1 != iBlowID )
			{
				pBubbleSystem->AddBubbleStateBlow( m_iBubbleTypeID, iBlowID );
			}
		}
	}

	SAFE_RELEASE_SPTR( m_hSkill );
}
//////////////////////////////////////////////////////////////////////////

// CDnEnchantSkillOnce
void CDnEnchantSkillOnce::Initialize( DnActorHandle hActor, const char* pArgument )
{
	if( !hActor || NULL == pArgument )
		return;

	m_hActor = hActor;
	_ASSERT( m_hActor->IsPlayerActor() );

	std::vector<string> vlTokens;
	string strArgument( pArgument );
	TokenizeA( strArgument, vlTokens, ";" );

	_ASSERT( 2 == (int)vlTokens.size() );

	m_iTargetSkillID = atoi( vlTokens.at(0).c_str() );
	m_iEnchantSkillID = atoi( vlTokens.at(1).c_str() );
}

void CDnEnchantSkillOnce::ProcessEvent( CDnBubbleSystem* pBubbleSystem, ::IDnObserverNotifyEvent* /*pEvent*/ )
{
	if( m_hActor->IsPlayerActor() )
	{
		CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(m_hActor.GetPointer());
		pPlayerActor->ApplyEnchantSkillOnceFromBubble( m_iTargetSkillID, m_iEnchantSkillID );

		// Ŭ¶óÀ̾ðÆ®ÀÇ ½ºÅ³Àº °­È­µÇÁö ¾Ê°í ¼­¹ö¸¸ Çѹø¸¸ °­È­ 󸮵Ê.
		// ¸ñÀûÀÌ ¿ø·¡ÀÇ ½ºÅ³ »óÅÂÈ¿°ú¸¦ º¯°æ½ÃÅ°´Â °ÍÀ̹ǷΠ»óÅÂÈ¿°úµéÀÌ ¼­¹ö¿¡¼­ ¸ðµÎ ÆÐŶÀ¸·Î Àü¼ÛµÇ°í Àֱ⠶§¹®¿¡
		// °ÔÀÓ¼­¹ö¿¡¼­¸¸ ½ºÅ³ »ç¿ëÇÒ ¶§ Çѹø ¹Ù²Ù´Â °É ó¸®ÇÑ´Ù.
		// ÇöÀç·Î¼­´Â Ŭ¶óÀ̾ðÆ®¿¡¼­ ½ºÅ³ »ç¿ëÀü¿¡ ¹Ì¸® °­È­½Ãų ¹æ¹ýÀÌ ¾øÀ¸¹Ç·Î ÀÌ·¸°Ô ÇÑ´Ù.
	}
} 
//////////////////////////////////////////////////////////////////////////

}