#include "stdafx.h"

#include "SHuntaHolicSystem.h"
//#include "SGameMessageUI.h"
#include "ErrorCode/ErrorCode.h"
#include "SHuntaHolicResourceDB.h"
#include "SWorldLocationDB.h"
#include "TemplateUtil.h"
#include "SStringDB.h" // sonador #2.1.2.11.5

#include "SDebug_Util.h"

namespace hhi = huntaholic_interface;

namespace {

	const char* mask_red		= "<#ed1c24>";
	const char* mask_green		= "<#cfff0e>";
	const char* mask_blue		= "<#0072bc>";
	const char* mask_white		= "<#fffffff>";

}

SHuntaHolicSystem::SHuntaHolicSystem( const char* name, SContentsManager& contentsMgr ) 
	: SContents( name, contentsMgr )
	, mTimeLimit( 0 )
	, mGuiLobby( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_LOBBY )
	, mGuiInstance( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_INSTANCE )
	, mGuiScoreBoard( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_SCOREBOARD )
	, mGuiResult( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_RESULT )
	, mGuiCreateInstance( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CREATE_INSTANCE )
	, mGuiConfirmPassword( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CONFIRM_PASSWORD )
	, mGuiPartyCommand( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_PARTY )
	, mInstanceStartTime( 0 )
	, mIsInHuntaHolic( false )
{
	defMsgProc( MSG_HUNTAHOLIC_INSTANCE_LIST, &SHuntaHolicSystem::onInstanceList );
	defMsgProc( MSG_HUNTAHOLIC_INSTANCE_INFO, &SHuntaHolicSystem::onInstanceInfo );
	defMsgProc( MSG_HUNTAHOLIC_HUNTING_SCORE, &SHuntaHolicSystem::onHuntingScore );
	defMsgProc( MSG_HUNTAHOLIC_UPDATE_SCORE, &SHuntaHolicSystem::onUpdateScore );
	defMsgProc( MSG_HUNTAHOLIC_BEGIN_HUNTING, &SHuntaHolicSystem::onBeginHunting );
	defMsgProc( MSG_CHANGE_LOCATION, &SHuntaHolicSystem::onChangeLocation );
	defMsgProc( MSG_RESULT, &SHuntaHolicSystem::onMsgResult );
	defMsgProc( MSG_HUNTAHOLIC_MAX_POINT_ACHIEVED, &SHuntaHolicSystem::onMaxPointAchieved ); // sonador #2.1.2.11.5

	mMyInstance.init();
}

void SHuntaHolicSystem::process( DWORD time )
{
	if( !isHunting() )
		return;

	AR_TIME currArTime = GetArTime();
	AR_TIME huntingPeriod = GetHuntaHolicResourceDB().Find( mLobby.huntaholic_id ).hunting_period * 100;

	if( currArTime < mInstanceStartTime )
	{
		mTimeLimit = huntingPeriod;
	}
	else
	{
		mTimeLimit = huntingPeriod - ( currArTime - mInstanceStartTime );
	}

	if( mGuiScoreBoard )
	{
		if( mTimeLimit <= 30000 )
			mGuiScoreBoard->Perform( hhi::id_updateTimeLimit, hhi::updateTimeLimit( mask_red ) );
		else
			mGuiScoreBoard->Perform( hhi::id_updateTimeLimit, hhi::updateTimeLimit( mask_green ) );
	}
}

void SHuntaHolicSystem::reset()
{
	mLobby.init();
	mInstanceList.clear();
	mMyInstance.init();
	mMyScore.init();
	mInstanceStartTime = 0;
}

void SHuntaHolicSystem::reqInstanceList( int page ) const
{
	TS_CS_HUNTAHOLIC_INSTANCE_LIST reqMsg;

	reqMsg.page = page;

	mContentsMgr.sendMsg( reqMsg );
}

void SHuntaHolicSystem::reqCreateInstance()
{
	mGuiCreateInstance->Perform( hhi::id_setCallBack, hhi::setCallBack( this ) );
	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CREATE_INSTANCE, true, true ) );
}

void SHuntaHolicSystem::reqJoinInstance( int index )
{
	if( index < 0 || index >= (int)mInstanceList.size() )
		return;

	mMyInstance = mInstanceList[ index ];

	if( mMyInstance.require_password )
	{
		mGuiConfirmPassword->Perform( hhi::id_setCallBack, hhi::setCallBack( this ) );
		mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CONFIRM_PASSWORD, true, true ) );
		return;
	}

	TS_CS_HUNTAHOLIC_JOIN_INSTANCE joinMsg;

	joinMsg.instance_no = mMyInstance.instance_no;
	::memset( joinMsg.password, 0, sizeof( joinMsg.password ) );

	mContentsMgr.sendMsg( joinMsg );
}

void SHuntaHolicSystem::reqLeaveInstance() const
{
	mContentsMgr.sendMsg( TS_CS_HUNTAHOLIC_LEAVE_INSTANCE() );
}

void SHuntaHolicSystem::reqLeaveHuntaHolic()
{
	mContentsMgr.sendMsg( TS_CS_HUNTAHOLIC_LEAVE_LOBBY() );
}

void SHuntaHolicSystem::reqBeginHuntaHolic()
{
	mContentsMgr.sendMsg( TS_CS_HUNTAHOLIC_BEGIN_HUNTING() );
}

unsigned int SHuntaHolicSystem::getArTimeLimitByMinutes() const
{
	return (unsigned int)( getArTimeLimit() / 6000 );
}

void SHuntaHolicSystem::onCreateInstance( const TS_CS_HUNTAHOLIC_CREATE_INSTANCE& createArg ) const
{
	mContentsMgr.sendMsg( createArg );
}

void SHuntaHolicSystem::onConfirmPassword( const char* password ) const
{
	TS_CS_HUNTAHOLIC_JOIN_INSTANCE joinMsg;

	joinMsg.instance_no = mMyInstance.instance_no;
	::strcpy_s( joinMsg.password, password );

	mContentsMgr.sendMsg( joinMsg );
}

void* SHuntaHolicSystem::Perform( KID id, KArg& msg )
{
	if( id == hhi::id_onCreateInstance )
	{
		hhi::onCreateInstance* realMsg = static_cast< hhi::onCreateInstance* >( &msg );
		onCreateInstance( realMsg->createArg );
	}
	else if( id == hhi::id_onConfirmPassword )
	{
		hhi::onConfirmPassword* realMsg = static_cast< hhi::onConfirmPassword* >( &msg );
		onConfirmPassword( realMsg->password ); 
	}

	return (void*)1;
}

bool SHuntaHolicSystem::isObjCompleted() const
{
	return mMyScore.score >= GetHuntaHolicResourceDB().Find( mLobby.huntaholic_id ).objective_point ? true : false;
}

void SHuntaHolicSystem::onInstanceList( SGameMessage* msg )
{
	SMSG_HUNTAHOLIC_INSTANCE_LIST* instanceList = static_cast< SMSG_HUNTAHOLIC_INSTANCE_LIST* >( msg );

	mLobby.huntaholic_id	= instanceList->huntaholic_id;
	mLobby.page				= ::min( instanceList->page, instanceList->total_page );
	mLobby.count			= instanceList->count;
	mLobby.total_page		= instanceList->total_page;

	HuntaHolicInstance* instanceInfo = instanceList->instance_info;
	
	mGuiLobby->Perform( hhi::id_refreshLobby );

	mInstanceList.clear();

	for( int i = 0; i < mLobby.count; ++i )
	{
		mInstanceList.push_back( *( instanceInfo++ ) );
		mGuiLobby->Perform( hhi::id_refreshInstance, hhi::refreshInstance( i ) );
	}

	if( isInInstance() )
	{
		mGuiLobby->Perform( hhi::id_disableUserCommand );
	}
	else
	{
		mGuiLobby->Perform( hhi::id_enableUserCommand );
	}
}

void SHuntaHolicSystem::onInstanceInfo( SGameMessage* msg )
{
	SMSG_HUNTAHOLIC_INSTANCE_INFO* instanceInfo = static_cast< SMSG_HUNTAHOLIC_INSTANCE_INFO* >( msg );

	mMyInstance = instanceInfo->info;

	mGuiInstance->Perform( hhi::id_updateMyInstance );
}

void SHuntaHolicSystem::onHuntingScore( SGameMessage* msg )
{
	SMSG_HUNTAHOLIC_HUNTING_SCORE* score = static_cast< SMSG_HUNTAHOLIC_HUNTING_SCORE* >( msg );

	mMyScore.huntaholic_id	 		= score->huntaholic_id;
	mMyScore.personal_kill_count	= score->personal_kill_count;
	mMyScore.personal_score			= score->personal_score;
	mMyScore.kill_count				= score->kill_count;
	mMyScore.score					= score->score;
	mMyScore.point_advantage		= score->point_advantage;
	mMyScore.point_rate				= score->point_rate;
	mMyScore.gain_point				= score->gain_point;
	mMyScore.is_retired				= score->is_retired;

	endHunting();

	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_SCOREBOARD, false, false ) );
	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_RESULT, true, false ) );

	mMyInstance.init();
	mGuiResult->Perform( hhi::id_showResult );
	mGuiLobby->Perform( hhi::id_enableUserCommand );
}

void SHuntaHolicSystem::onUpdateScore( SGameMessage* msg )
{
	SMSG_HUNTAHOLIC_UPDATE_SCORE* updateScore = static_cast< SMSG_HUNTAHOLIC_UPDATE_SCORE* >( msg );

	int scoreDiff = 0;

	if( updateScore->score )
		scoreDiff = updateScore->score - mMyScore.score;

	mMyScore.kill_count = updateScore->kill_count;
	mMyScore.score		= updateScore->score;

	int objectivePoint = GetHuntaHolicResourceDB().Find( mLobby.huntaholic_id ).objective_point;

	if( mMyScore.score < objectivePoint )
	{
		mGuiScoreBoard->Perform( hhi::id_setScoreBoardNormalMode );
		mGuiScoreBoard->Perform( hhi::id_updateScore, hhi::updateScore( mask_white ) );
	}
	else
	{
		mGuiScoreBoard->Perform( hhi::id_setScoreBoardCompleteMode );
		mGuiScoreBoard->Perform( hhi::id_updateScore, hhi::updateScore( mask_blue ) );
	}

	if( scoreDiff > 2 )
	{
		mGuiScoreBoard->Perform( hhi::id_updateKillCountByExplosionFx );
	}
	else if( scoreDiff > 0 )
	{
		mGuiScoreBoard->Perform( hhi::id_updateKillCountByWaterFallFx );
	}
	else
	{
		mGuiScoreBoard->Perform( hhi::id_updateKillCount );
	}
}

void SHuntaHolicSystem::onBeginHunting( SGameMessage* msg )
{
	SMSG_HUNTAHOLIC_BEGIN_HUNTING* real = static_cast< SMSG_HUNTAHOLIC_BEGIN_HUNTING* >( msg );

	beginHunting( real->begin_time );

	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_LOBBY, false ) );
	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_INSTANCE, false ) );
	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_SCOREBOARD, true ) );

	mMyScore.init();

	mGuiScoreBoard->Perform( hhi::id_updateTimeLimit, hhi::updateTimeLimit( mask_green ) );
	mGuiScoreBoard->Perform( hhi::id_updateScore, hhi::updateScore( mask_white ) );
	mGuiScoreBoard->Perform( hhi::id_setScoreBoardNormalMode ); // sonador #2.3.1.42
	mGuiScoreBoard->Perform( hhi::id_updateKillCount );
}

// sonador #2.1.2.11.5
void SHuntaHolicSystem::onMaxPointAchieved( SGameMessage* msg )
{
	mContentsMgr.sendInterfaceMsg( 
		SIMSG_REQ_OPEN_MSGBOX( 
			SIMSG_REQ_OPEN_MSGBOX::MSGBOX_HUNTAHOLIC_MAXPOINT, 
			S( 999 ), 
			"huntaholic_have_aquired_max_points" ) );
}

void SHuntaHolicSystem::onChangeLocation( SGameMessage* msg )
{
	SMSG_CHANGE_LOCATION* loc = static_cast< SMSG_CHANGE_LOCATION* >( msg );

	const WorldLocationBase* locInfo = GetWorldLocationDB().GetWLData( loc->cur_location_id, 0, 0 );

	if( !locInfo )
		return;

	if( locInfo->location_type == WorldLocationBase::LOCTYPE_HUNTAHOLIC_LOBBY || 
		locInfo->location_type == WorldLocationBase::LOCTYPE_HUNTAHOLIC_DUNGEON )
		enterHuntaHolic();
	else
		leaveHuntaHolic();
}

void SHuntaHolicSystem::onMsgResult( SGameMessage* msg )
{
	SMSG_RESULT* result = static_cast< SMSG_RESULT* >( msg );

	switch( result->request_msg_id )
	{
	case TM_CS_HUNTAHOLIC_CREATE_INSTANCE:
	case TM_CS_HUNTAHOLIC_JOIN_INSTANCE:
		{
			if( result->result == RESULT_SUCCESS )
			{
				mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_LOBBY, false ) );
				mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_INSTANCE, true ) );

				mGuiInstance->Perform( hhi::id_updateMyInstance );
				mGuiLobby->Perform( hhi::id_disableUserCommand );
			}
		}
		break;
	case TM_CS_HUNTAHOLIC_LEAVE_INSTANCE:
		{
			if( result->result == RESULT_SUCCESS )
			{
				mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_INSTANCE, false ) );
				mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CREATE_INSTANCE, false ) );
				mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CONFIRM_PASSWORD, false ) );
				mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_SCOREBOARD, false ) );

				mMyInstance.init();
				mGuiInstance->Perform( hhi::id_updateMyInstance );
				mGuiLobby->Perform( hhi::id_enableUserCommand );

				reqInstanceList( mLobby.page );
			}
		}
		break;
	case TM_CS_HUNTAHOLIC_LEAVE_LOBBY:
		{
			// 캐릭터가 헌터홀릭 로비 내에 존재하지 않습니다.(로비 외의 지역에 있습니다)
			if( result->result == RESULT_ACCESS_DENIED )
			{
			}
			// 캐릭터가 특정 헌터홀릭 인스턴스 내에 소속되어 있습니다. 소속되어 있는
			// 헌터홀릭 인스턴스에서 나간 후에 재시도하여야 합니다.
			else if( result->result == RESULT_NOT_ACTABLE )
			{
			}
			// 로비에서 성공적으로 나가는 처리가 이루어져서 곧 워프될 예정입니다.
			else if( result->result == RESULT_SUCCESS )
			{
				leaveHuntaHolic();
			}
		}
		break;
	}
}

void SHuntaHolicSystem::enterHuntaHolic()
{
	if( !mIsInHuntaHolic )
	{
		mGuiPartyCommand->Perform( hhi::id_disablePartyCommand );
		mIsInHuntaHolic = true;
	}
}

void SHuntaHolicSystem::leaveHuntaHolic()
{
	if( mIsInHuntaHolic )
	{
		//
		// close all windows 
		// 

	mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_LOBBY, false ) );
		mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_INSTANCE, false ) );
		mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_SCOREBOARD, false ) );
		mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_RESULT, false ) );
		mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CREATE_INSTANCE, false ) );
		mContentsMgr.sendInterfaceMsg( SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_HUNTAHOLIC_CONFIRM_PASSWORD, false ) );

		mGuiPartyCommand->Perform( hhi::id_enablePartyCommand );
		mIsInHuntaHolic = false;
	}
}

#if defined( __TEST_HUNTAHOLICSYSTEM )
void testInputInfo( HuntaHolicInstance& info, int no, const char* name, int memberCount, int maxMemberCount, bool reqPW )
{
	info.instance_no			= no;	
	::strcpy_s( info.name, name );
	info.current_member_count	= memberCount;	
	info.max_member_count		= maxMemberCount;
	info.require_password		= reqPW;
}

void SHuntaHolicSystem::testInstanceList()
{
	SMSG_HUNTAHOLIC_INSTANCE_LIST* instanceList = new SMSG_HUNTAHOLIC_INSTANCE_LIST();

	mLobby.huntaholic_id	= 1000;
	mLobby.page				= 1;
	mLobby.count			= 18;
	mLobby.total_page		= 1;
	
	mGuiLobby->Perform( hhi::id_refreshLobby );

	{
		HuntaHolicInstance sample;

		testInputInfo( sample, 0, "1", 1, 4, true );
		mInstanceList.push_back( sample );
		
		testInputInfo( sample, 1, "2", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 2, "3", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 3, "4", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 4, "5", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 5, "6", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 6, "7", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 7, "8", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 8, "9", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample, 9, "10", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,10, "11", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,11, "12", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,12, "13", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,13, "14", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,14, "15", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,15, "16", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,16, "17", 1, 4, true );
		mInstanceList.push_back( sample );

		testInputInfo( sample,17, "18", 1, 4, true );
		mInstanceList.push_back( sample );
	}

	for( int i = 0; i < 18; ++i )
		mGuiLobby->Perform( hhi::id_refreshInstance, hhi::refreshInstance( i ) );
}
#endif