#include "stdafx.h"
#include "Arena\\ArenaJoinSituationChecker.h"
#include "Arena\\ArenaSystem.h"
#include "Arena\\ArenaUtility.h"
#include "SGameManager.h"
#include "SBattleArenaDB.h"
#include "SGameInterface.h"
#include "SGameAvatarEx.h"
#include "SPlayerInfoMgr.h"
#include "SUIDisplayInfo.h"
#include "SGameSystem.h"
#include "SGameSystem.h"
#include <toolkit/XStringUtil.h>
#include "ErrorCode/ErrorCode.h"
#include "SStringDB.h"
#include "SGame.h"

extern SGameSystem* g_pCurrentGameSystem;

void SGameInterface::recvMsgResultBattleArenaJoinQueue(int result)
{
	int stringId;
	switch (result)
	{
	case RESULT_SUCCESS:											return ;
	case RESULT_NOT_ENOUGH_HP:								stringId = 2423;	break;
	case RESULT_NOT_ACTABLE_WHILE_TRADING:				stringId = 2424;	break;
	case RESULT_NOT_ACTABLE_IN_HUNTAHOLIC:				stringId = 2425;	break;
	case RESULT_NOT_ACTABLE_IN_DEATHMATCH:			stringId = 2425;	break;
	case RESULT_NOT_ACTABLE_IN_INSTANCE_DUNGEON:	stringId = 2425;	break;
	case RESULT_NOT_ACTABLE_IN_SIEGE_OR_RAID:			stringId = 2426;	break;
	case RESULT_ALREADY_EXIST:									return ;
	case RESULT_NOT_ENOUGH_LEVEL:							return ;
	case RESULT_LIMIT_MAX:										stringId = 2469;	break;	
	case RESULT_UNKNOWN:										stringId = 831;	break;	
	case RESULT_NOT_EXIST:										stringId = 2469;	break;	
	case RESULT_ACCESS_DENIED:								stringId = 2469;	break;
	case RESULT_COOL_TIME:
		{
			sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();
			int blockTime = arenaSystem->getBlockTime();
			ProcMsgAtStatic(&SMSG_SEND_DATA(2420, "open_panelty_message_box", blockTime, arenaSystem->getPenaltyCount(), ""));
			return ;
		}
	default: return ;
	}

	setArenaJoinSituation(S(stringId));
}

void SGameInterface::recvMsgResultBattleArenaLeave(int result)
{
	/// leave를 보냈는데, success가 아니면 그 다음 패킷이 안 날라와서 ui가 남아 있는 경우가 있다.
	/// 이런 경우를 대비해서 성공이 아니면 아레나 관련 ui를 모두 hide 시켜준다
	if (RESULT_SUCCESS != result)
	{
		hideAllBattleArenaWnd();
	}

	int stringId;
	switch (result)
	{
	case RESULT_SUCCESS:					return ;
	case RESULT_NOT_EXIST:				return ;
	case RESULT_INVALID_ARGUMENT:	stringId = 831;	break;
	default:									return ;
	}

	setArenaJoinSituation(S(stringId));
}

void SGameInterface::recvMsgResultBattleArenaEnterWhileCountdown(int result)
{
	int stringId;
	switch (result)
	{
	case RESULT_SUCCESS:					return ;
	case RESULT_NOT_EXIST:				return ;
	case RESULT_INVALID_ARGUMENT:	stringId = 831;	break;
	case RESULT_NOT_ACTABLE:			return ;
	case RESULT_ACCESS_DENIED:		return ;
	default:	return ;
	}

	setArenaJoinSituation(S(stringId));
}

void SGameInterface::recvMsgResultBattleArenaExerciseReady(int result)
{
	char const* str;
	switch (result)
	{
	case RESULT_SUCCESS:					return ;
	case RESULT_NOT_EXIST:				return ;
	case RESULT_ACCESS_DENIED:		return ;
	case RESULT_LIMIT_MIN:				str = "test 경기를 할 수 있은 인원 미달";	break;
	default:									return ;
	}

	setArenaJoinSituation(str);
}

void SGameInterface::recvMsgResultBattleArenaExerciseStart(int result)
{
	int stringId;
	switch (result)
	{
	case RESULT_SUCCESS:					return ;
	case RESULT_NOT_EXIST:				return ;
	case RESULT_NOT_ACTABLE:			stringId = 2470;	break;
	case RESULT_ACCESS_DENIED:		return ;
	case RESULT_NOT_READY:				stringId = 2471;	break;
	case RESULT_INVALID_ARGUMENT:	stringId = 831;	break;
	}

	setArenaJoinSituation(S(stringId));
}

void SGameInterface::recvMsgResultBattleArenaChangeAlias(SGameMessage* msg)
{
	SMSG_RESULT* _msg = dynamicCast<SMSG_RESULT*>(msg);
	if (RESULT_SUCCESS == _msg->result)
	{
		m_pGameManager->ProcMsgAtStatic( &SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_INPUTTEXT, false ) );
	}
	else if (RESULT_ALREADY_EXIST == _msg->result)
	{
		std::string alias = SR(2496, "#@arena_hide_name@#", m_pDisplayInfo->GetPlayerInfoManager()->GetAlias());
		setArenaJoinSituation(alias.c_str());
		return ;
	}
	else
	{
		/// 적절한 처리
	}

	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_MENU, msg);
}

void SGameInterface::recvMsgResultBattleArenaAbsenceRequest(int result)
{
	std::string str;
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();

	switch (result)
	{
	case RESULT_SUCCESS:				return ;
	case RESULT_NOT_EXIST:			return ;
	case RESULT_COOL_TIME:
	case RESULT_ALREADY_EXIST:		str = SR(2445, "#@player_name@#", arenaSystem->getReportDrivePlayerName());	break;
	case RESULT_LIMIT_TARGET:		str = S(2472);	break;
	}

	setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_NOTIFICATION_WND);
}

void SGameInterface::recvMsgBattleArenaJoinQueue(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaJoinQueue(msg);

	/// 처음 참여할 때는 여기서 arenaId를 설정하지만, 중간에 참여할 때는 이 메세지가 안나라오기 때문에, 거기에 맞게 설정을 해줘야 된다.
	SMSG_BATTLE_ARENA_JOIN_QUEUE* _msg = dynamicCast<SMSG_BATTLE_ARENA_JOIN_QUEUE*>(msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_MENU, msg);

	/// 연습경기는 여기에 날라오지 않는다
	if (sArenaUtility::EXERCISE_ARENA_ID != _msg->arenaId)
	{
		/// 선택 입장 일 경우에
		if (0 != _msg->arenaId)
			ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_SELECTION_READY, msg);
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_WAITING, msg);
	}
}

void SGameInterface::recvMsgBattleArenaLeave(SGameMessage* msg)
{
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();
	arenaSystem->recvMsgBattleArenaLeave(msg);

	SMSG_BATTLE_ARENA_LEAVE* _msg = dynamicCast<SMSG_BATTLE_ARENA_LEAVE*>(msg);

	bool isLocalPlayer = false;
	if (g_pCurrentGameSystem->isLocalPlayerName(_msg->name))
		isLocalPlayer = true;

	_ARENA_LEAVE_TYPE leaveType = _msg->leaveType;
	if (ALT_UNKNOWN == leaveType)
	{
	}
	else if (ALT_USER_REQUEST == leaveType)
	{
		if (arenaSystem->isPlaying())
		{
			if (!isLocalPlayer)
			{
				std::string str = SR(2440, "#@player_name@#", (char const*)_msg->name);
				setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
			}
			/// 모험 종료인지 일반 나가기인지 구분이 되지 않기 때문에 출력하지 않는다
			/*
			else
			{
				if (g_pCurrentGameSystem->isInArena())
					setArenaJoinSituation(S(2447), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
			}
			*/
		}
	}
	else if (ALT_GAME_OVER == leaveType)
	{		
	}
	/// 참여 할려고 하는데, 베어로드/인던 파티에 참여 중일 때
	else if (ALT_PARTICIPATING_SPECIAL_PARTY == leaveType || ALT_FAILED_TO_JOIN_BATTLE == leaveType)
	{
		if (arenaSystem->isWaiting())
		{
			/// 거래/죽기 체크
			sArenaJoinSituationCondition situationCondition;
			/// way
			situationCondition.m_notificationWays = cArenaJoinSituationChecker::WAY_MSG_BOX;
			/// situation
			situationCondition.add(cArenaJoinSituationChecker::SITUATION_DEATH, S(2437));
			situationCondition.add(cArenaJoinSituationChecker::SITUATION_TRADE, S(2438));

			g_pCurrentGameSystem->isValidArenaJoinSituation(situationCondition);
		}
	}
	/// 자신은 정상 시작을 했는데, 상대편이 어떤 이유로 해서 아무도 없을 경우
	else if (ALT_FAILED_TO_START_BATTLE == leaveType)
	{
	}
	else if (ALT_DISCONNECT == leaveType)
	{
		if (arenaSystem->isPlaying())
		{
			if (!isLocalPlayer)
			{
				std::string str = SR(2440, "#@player_name@#", (char const*)_msg->name);
				setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
			}
		}
	}
	else if (ALT_ABSENT == leaveType)
	{
		if (arenaSystem->isPlaying())
		{
			std::string str = SR(2446, "#@player_name@#", (char const*)_msg->name);
			setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
		}
	}

	if (isLocalPlayer)
	{
		hideAllBattleArenaWnd();
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_CHATTING, msg);
		arenaSystem->clear();

		/// 이름 변경
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_MAINFRAME, msg);
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_CHARINFO, msg);
		updatePlayerName();
	}
	else
	{		
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_RESULT, msg);

		if (arenaSystem->isExercise())
		{
			ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_WAITING, msg);
		}
		else
		{
			ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_WAITING, msg);
		}
	}

	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(g_pCurrentGameSystem->getArenaId());
	ProcMsgToUIWindow(wndId, msg);
}

void SGameInterface::recvMsgBattleArenaBattleInfo(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaBattleInfo(msg);

	SMSG_BATTLE_ARENA_BATTLE_INFO* _msg = dynamicCast<SMSG_BATTLE_ARENA_BATTLE_INFO*>(msg);
	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(_msg->arenaId);
	ProcMsgToUIWindow(wndId, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_GAME_BINGO_BOARD, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_RESULT, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_MENU, msg);

	/// 
	if (sArenaUtility::EXERCISE_ARENA_ID == _msg->arenaId)
	{
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_READY, msg);
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_WAITING, msg);
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_GUIDE_TOOLTIP, msg);
	}
	else
	{
		/// 아직 경기 시작 시간이 남아 있으면 카운트를 해준다
		if (_msg->forceEnterTime > GetArTime())
			ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_WAITING, msg);
		/// 카운트 중인 경기에 참여 했을 때, SELECTION_READY창을 닫아 줘야 된다
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_SELECTION_READY, msg);
	}

	/// 이름 변경
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_MAINFRAME, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_CHARINFO, msg);
	updatePlayerName();

	/// 파티창 타이틀 업데이트
	m_pGameManager->ProcMsgAtStatic( &SIMSG_UI_SEND_DATA( SIMSG_TOGGLE_UIWINDOW::_UIWINDOW_TYPE::UIWINDOW_PARTY, "refreshAllTitle"));

	isValidArenaJoinSituationAtBattleInfo();
}

void SGameInterface::recvMsgBattleArenaBattleStatus(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaBattleStatus(msg);

	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(g_pCurrentGameSystem->getArenaId());
	ProcMsgToUIWindow(wndId, msg);

	if (SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_GAME_BINGO == wndId)
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_GAME_BINGO_BOARD, msg);
}

void SGameInterface::recvMsgBattleArenaBattleScore(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaBattleScore(msg);

	SMSG_BATTLE_ARENA_BATTLE_SCORE* _msg = dynamicCast<SMSG_BATTLE_ARENA_BATTLE_SCORE*>(msg);
	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(g_pCurrentGameSystem->getArenaId());
	ProcMsgToUIWindow(wndId, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_RESULT, msg);
}

void SGameInterface::recvMsgBattleArenaJoinBattle(SGameMessage* msg)
{
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();
	arenaSystem->recvMsgBattleArenaJoinBattle(msg);

	SMSG_BATTLE_ARENA_JOIN_BATTLE* _msg = dynamicCast<SMSG_BATTLE_ARENA_JOIN_BATTLE*>(msg);
	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(g_pCurrentGameSystem->getArenaId());
	ProcMsgToUIWindow(wndId, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_RESULT, msg);

	if (sArenaUtility::EXERCISE_ARENA_ID == g_pCurrentGameSystem->getArenaId())
	{
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_WAITING, msg);
	}
	else
	{
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_WAITING, msg);
	}

	/// 자신은 제외
	if (!g_pCurrentGameSystem->isLocalPlayerName(_msg->name))
	{
		std::string str = S(2441);
		/// player name
		XStringUtil::Replace(str, "#@player_name@#", _msg->name);
		/// team name
		sArenaUtility utility;
		int team = arenaSystem->findTeam(_msg->name);
		char const* teamName = utility.teamToStr(team);
		XStringUtil::Replace(str, "#@arena_team@#", teamName);

		setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
	}
}

void SGameInterface::recvMsgBattleArenaDisconnectBattle(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaDisconnectBattle(msg);

	SMSG_BATTLE_ARENA_DISCONNECT_BATTLE* _msg = dynamicCast<SMSG_BATTLE_ARENA_DISCONNECT_BATTLE*>(msg);

	SGameAvatarEx* player = dynamicCast<SGameAvatarEx*>(g_pCurrentGameSystem->GetGame()->GetGameObject(_msg->handle));
	if (!player)
		return ;
	
	std::string str = SR(2440, "#@player_name@#", player->GetName());
	setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
}

void SGameInterface::recvMsgBattleArenaReconnectBattle(SGameMessage* msg)
{
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();
	arenaSystem->recvMsgBattleArenaReconnectBattle(msg);

	SMSG_BATTLE_ARENA_RECONNECT_BATTLE* _msg = dynamicCast<SMSG_BATTLE_ARENA_RECONNECT_BATTLE*>(msg);
	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(g_pCurrentGameSystem->getArenaId());
	ProcMsgToUIWindow(wndId, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_RESULT, msg);

	/// 공지
	std::string str = S(2483);
	/// player name
	XStringUtil::Replace(str, "#@player_name@#", _msg->name);
	/// team name
	int team = arenaSystem->findTeam(_msg->name);
	char const* teamName = utility.teamToStr(team);
	XStringUtil::Replace(str, "#@arena_team@#", teamName);
	setArenaJoinSituation(str.c_str(), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
}

void SGameInterface::recvMsgBattleArenaResult(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaResult(msg);

	hideAllBattleArenaWnd();

	/// 로딩중에 result를 받을 수 있기 때문에, show 될 때 거기에 맞게 처리하기 위해서 게임 ui에도 보낸다
	sArenaUtility utility;
	int wndId = utility.getArenaGameWindowId(g_pCurrentGameSystem->getArenaId());
	ProcMsgToUIWindow(wndId, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_RESULT, msg);

	/// 캐스팅 중이면 취소 시킨다
	SGameAvatarEx* localPlayer = g_pCurrentGameSystem->GetLocalPlayer();
	if (localPlayer && localPlayer->IsCasting())
	{
		m_pGameManager->PostMsgAtDynamic( new SMSG_SEND_DATA( "cancel_casting" ) ); 
	}
}

void SGameInterface::recvMsgBattleArenaAbsenceCheck(SGameMessage *msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaAbsenceCheck(msg);

	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_REPORT_DIVE, msg);
}

void SGameInterface::recvMsgBattleArenaPenaltyInfo(SGameMessage* msg)
{
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();

	int oldPenaltyCount = arenaSystem->getPenaltyCount();
	arenaSystem->recvMsgBattleArenaPenaltyInfo(msg);
	/// -1은 맨처음 접속 했을 때의 초기 값이다.
	if (-1 != oldPenaltyCount && oldPenaltyCount < arenaSystem->getPenaltyCount())
	{
		if (1 == arenaSystem->getPenaltyCount())
			setArenaJoinSituation(S(2447), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
		else
			setArenaJoinSituation(S(2448), cArenaJoinSituationChecker::WAY_CENTER_NOTICE);
	}
}

void SGameInterface::recvMsgBattleArenaUpdateWaitUserCount(SGameMessage* msg)
{
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();
	arenaSystem->recvMsgBattleArenaUpdateWaitUserCount(msg);

	if (arenaSystem->isExercise())
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_WAITING, msg);
	else
		ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_WAITING, msg);
}

void SGameInterface::recvMsgBattleArenaExerciseReadyStatus(SGameMessage* msg)
{
	g_pCurrentGameSystem->getArenaSystem()->recvMsgBattleArenaExerciseReadyStatus(msg);

	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_WAITING, msg);
}

void SGameInterface::recvMsgBattleArenaPromote(SGameMessage* msg)
{
	sArenaSystem* arenaSystem = g_pCurrentGameSystem->getArenaSystem();
	if (!arenaSystem->isExercise())
		return ;

	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_GAME_SLAUGHTER_PRACTICE, msg);
	ProcMsgToUIWindow(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_ARENA_PRACTICE_WAITING, msg);
}

void SGameInterface::isValidArenaJoinSituationAtBattleInfo()
{
	sArenaJoinSituationCondition situationCondition;
	/// way
	situationCondition.m_notificationWays = cArenaJoinSituationChecker::WAY_NOTIFICATION_WND;
	/// situation
	situationCondition.add(cArenaJoinSituationChecker::SITUATION_DEATH, S(2456));
	situationCondition.add(cArenaJoinSituationChecker::SITUATION_TRADE, S(2457));

	g_pCurrentGameSystem->isValidArenaJoinSituation(situationCondition);
}