/**

 * vim: set ts=4 sw=4 tw=99 noet :

 * =============================================================================

 * SourceMod

 * Copyright (C) 2004-2009 AlliedModders LLC.  All rights reserved.

 * =============================================================================

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, version 3.0, as published by the

 * Free Software Foundation.

 * 

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to link the

 * code of this program (as well as its derivative works) to "Half-Life 2," the

 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

 * by the Valve Corporation.  You must obey the GNU General Public License in

 * all respects for all other code used.  Additionally, AlliedModders LLC grants

 * this exception to all derivative works.  AlliedModders LLC defines further

 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

 * or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include "PlayerManager.h"

#include "ForwardSys.h"

#include "ShareSys.h"

#include "AdminCache.h"

#include "ConCmdManager.h"

#include "MenuStyle_Valve.h"

#include "MenuStyle_Radio.h"

#include "sm_stringutil.h"

#include "CoreConfig.h"

#include "TimerSys.h"

#include "Logger.h"

#include "ChatTriggers.h"

#include "HalfLife2.h"

#include <inetchannel.h>

#include <iclient.h>

#include <IGameConfigs.h>

#include "ExtensionSys.h"

#include <sourcemod_version.h>

#include "ConsoleDetours.h"

#include "logic_bridge.h"

PlayerManager g_Players;

bool g_OnMapStarted = false;

IForward *PreAdminCheck = NULL;

IForward *PostAdminCheck = NULL;

IForward *PostAdminFilter = NULL;

const unsigned int *g_NumPlayersToAuth = NULL;

int lifestate_offset = -1;

List<ICommandTargetProcessor *> target_processors;

SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int);

SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *);

SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *);

#if SOURCE_ENGINE >= SE_ORANGEBOX

SH_DECL_HOOK2_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *, const CCommand &);

#else

SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);

#endif

SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *);

SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int);

#if SOURCE_ENGINE >= SE_ORANGEBOX

SH_DECL_EXTERN1_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommand &);

#elif SOURCE_ENGINE == SE_DARKMESSIAH

SH_DECL_EXTERN0_void(ConCommand, Dispatch, SH_NOATTRIB, false);

#else

# if SH_IMPL_VERSION >= 4

 extern int __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

# else

 extern bool __SourceHook_FHAddConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

# endif

extern bool __SourceHook_FHRemoveConCommandDispatch(void *,bool,class fastdelegate::FastDelegate0<void>);

#endif

ConCommand *maxplayersCmd = NULL;

unsigned int g_PlayerSerialCount = 0;

class KickPlayerTimer : public ITimedEvent

{

public:

	ResultType OnTimer(ITimer *pTimer, void *pData)

	{

		int userid = (int)pData;

		int client = g_Players.GetClientOfUserId(userid);

		if (client)

		{

			CPlayer *player = g_Players.GetPlayerByIndex(client);

			player->Kick("Your name is reserved by SourceMod; set your password to use it.");

		}

		return Pl_Stop;

	}

	void OnTimerEnd(ITimer *pTimer, void *pData)

	{

	}

} s_KickPlayerTimer;

PlayerManager::PlayerManager()

{

	m_AuthQueue = NULL;

	m_FirstPass = false;

	m_maxClients = 0;

	m_SourceTVUserId = -1;

	m_ReplayUserId = -1;

	m_bUseSteamAdminAuth = true; // use steam auth by default

	m_UserIdLookUp = new int[USHRT_MAX+1];

	memset(m_UserIdLookUp, 0, sizeof(int) * (USHRT_MAX+1));

}

PlayerManager::~PlayerManager()

{

	g_NumPlayersToAuth = NULL;

	delete [] m_AuthQueue;

	delete [] m_UserIdLookUp;

}

void PlayerManager::OnSourceModAllInitialized()

{

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

	SH_ADD_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

	g_ShareSys.AddInterface(NULL, this);

	ParamType p1[] = {Param_Cell, Param_String, Param_Cell};

	ParamType p2[] = {Param_Cell};

	m_clconnect = g_Forwards.CreateForward("OnClientConnect", ET_LowEvent, 3, p1);

	m_clconnect_post = g_Forwards.CreateForward("OnClientConnected", ET_Ignore, 1, p2);

	m_clputinserver = g_Forwards.CreateForward("OnClientPutInServer", ET_Ignore, 1, p2);

	m_cldisconnect = g_Forwards.CreateForward("OnClientDisconnect", ET_Ignore, 1, p2);

	m_cldisconnect_post = g_Forwards.CreateForward("OnClientDisconnect_Post", ET_Ignore, 1, p2);

	m_clcommand = g_Forwards.CreateForward("OnClientCommand", ET_Hook, 2, NULL, Param_Cell, Param_Cell);

	m_clinfochanged = g_Forwards.CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);

	m_clauth = g_Forwards.CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);

	m_onActivate = g_Forwards.CreateForward("OnServerLoad", ET_Ignore, 0, NULL);

	m_onActivate2 = g_Forwards.CreateForward("OnMapStart", ET_Ignore, 0, NULL);

	PreAdminCheck = g_Forwards.CreateForward("OnClientPreAdminCheck", ET_Event, 1, p1);

	PostAdminCheck = g_Forwards.CreateForward("OnClientPostAdminCheck", ET_Ignore, 1, p1);

	PostAdminFilter = g_Forwards.CreateForward("OnClientPostAdminFilter", ET_Ignore, 1, p1);

	m_bIsListenServer = !engine->IsDedicatedServer();

	m_ListenClient = 0;

	ConCommand *pCmd = FindCommand("maxplayers");

	if (pCmd != NULL)

	{

		SH_ADD_HOOK_STATICFUNC(ConCommand, Dispatch, pCmd, CmdMaxplayersCallback, true);

		maxplayersCmd = pCmd;

	}

}

void PlayerManager::OnSourceModShutdown()

{

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect, false);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientConnect, serverClients, this, &PlayerManager::OnClientConnect_Post, true);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientPutInServer, serverClients, this, &PlayerManager::OnClientPutInServer, true);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect, false);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientDisconnect, serverClients, this, &PlayerManager::OnClientDisconnect_Post, true);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientCommand, serverClients, this, &PlayerManager::OnClientCommand, false);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, ClientSettingsChanged, serverClients, this, &PlayerManager::OnClientSettingsChanged, true);

	SH_REMOVE_HOOK_MEMFUNC(IServerGameDLL, ServerActivate, gamedll, this, &PlayerManager::OnServerActivate, true);

	/* Release forwards */

	g_Forwards.ReleaseForward(m_clconnect);

	g_Forwards.ReleaseForward(m_clconnect_post);

	g_Forwards.ReleaseForward(m_clputinserver);

	g_Forwards.ReleaseForward(m_cldisconnect);

	g_Forwards.ReleaseForward(m_cldisconnect_post);

	g_Forwards.ReleaseForward(m_clcommand);

	g_Forwards.ReleaseForward(m_clinfochanged);

	g_Forwards.ReleaseForward(m_clauth);

	g_Forwards.ReleaseForward(m_onActivate);

	g_Forwards.ReleaseForward(m_onActivate2);

	g_Forwards.ReleaseForward(PreAdminCheck);

	g_Forwards.ReleaseForward(PostAdminCheck);

	g_Forwards.ReleaseForward(PostAdminFilter);

	delete [] m_Players;

	if (maxplayersCmd != NULL)

	{

		SH_REMOVE_HOOK_STATICFUNC(ConCommand, Dispatch, maxplayersCmd, CmdMaxplayersCallback, true);

	}

}

ConfigResult PlayerManager::OnSourceModConfigChanged(const char *key, 

												 const char *value, 

												 ConfigSource source, 

												 char *error, 

												 size_t maxlength)

{

	if (strcmp(key, "PassInfoVar") == 0)

	{

		if (strcmp(value, "_password") != 0)

		{

			m_PassInfoVar.assign(value);

		}

		return ConfigResult_Accept;

	} else if (strcmp(key, "AllowClLanguageVar") == 0) {

		if (strcasecmp(value, "on") == 0)

		{

			m_QueryLang = true;

		} else if (strcasecmp(value, "off") == 0) {

			m_QueryLang = false;

		} else {

			UTIL_Format(error, maxlength, "Invalid value: must be \"on\" or \"off\"");

			return ConfigResult_Reject;

		}

		return ConfigResult_Accept;

	} else if (strcmp( key, "SteamAuthstringValidation" ) == 0) {

		if (strcasecmp(value, "yes") == 0)

		{

			m_bUseSteamAdminAuth = true;

		} else if ( strcasecmp(value, "no") == 0) {

			m_bUseSteamAdminAuth = false;

		} else {

			UTIL_Format(error, maxlength, "Invalid value: must be \"yes\" or \"no\"");

			return ConfigResult_Reject;

		}

		return ConfigResult_Accept;

	}

	return ConfigResult_Ignore;

}

void PlayerManager::OnServerActivate(edict_t *pEdictList, int edictCount, int clientMax)

{

	static ConVar *tv_enable = icvar->FindVar("tv_enable");

#if SOURCE_ENGINE == SE_ORANGEBOXVALVE

	static ConVar *replay_enable = icvar->FindVar("replay_enable");

#endif

	// clientMax will not necessarily be correct here (such as on late SourceTV enable)

	m_maxClients = gpGlobals->maxClients;

	ICommandLine *commandLine = g_HL2.GetValveCommandLine();

	m_bIsSourceTVActive = (tv_enable && tv_enable->GetBool() && (!commandLine || commandLine->FindParm("-nohltv") == 0));

	m_bIsReplayActive = false;

#if SOURCE_ENGINE == SE_ORANGEBOXVALVE

	m_bIsReplayActive = (replay_enable && replay_enable->GetBool());

#endif

	m_PlayersSinceActive = 0;

	if (!m_FirstPass)

	{

		/* Initialize all players */

		m_PlayerCount = 0;

		m_Players = new CPlayer[ABSOLUTE_PLAYER_LIMIT + 1];

		m_AuthQueue = new unsigned int[ABSOLUTE_PLAYER_LIMIT + 1];

		m_FirstPass = true;

		memset(m_AuthQueue, 0, sizeof(unsigned int) * (ABSOLUTE_PLAYER_LIMIT + 1));

		g_NumPlayersToAuth = &m_AuthQueue[0];

	}

	g_PluginSys.SyncMaxClients(m_maxClients);

	g_OnMapStarted = true;

	g_Extensions.CallOnCoreMapStart(pEdictList, edictCount, m_maxClients);

	m_onActivate->Execute(NULL);

	m_onActivate2->Execute(NULL);

	List<IClientListener *>::iterator iter;

	for (iter = m_hooks.begin(); iter != m_hooks.end(); iter++)

	{

		if ((*iter)->GetClientListenerVersion() >= 5)

		{

			(*iter)->OnServerActivated(m_maxClients);

		}

	}

	SMGlobalClass *cls = SMGlobalClass::head;

	while (cls)

	{

		cls->OnSourceModLevelActivated();

		cls = cls->m_pGlobalClassNext;

	}

	SM_ExecuteAllConfigs();

}

bool PlayerManager::IsServerActivated()

{

	return m_FirstPass;

}

bool PlayerManager::CheckSetAdmin(int index, CPlayer *pPlayer, AdminId id)

{

	const char *password = g_Admins.GetAdminPassword(id);

	if (password != NULL)

	{

		if (m_PassInfoVar.size() < 1)

		{

			return false;

		}

		/* Whoa... the user needs a password! */

		const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

		if (!given || strcmp(given, password) != 0)

		{

			return false;

		}

	}

	pPlayer->SetAdminId(id, false);

	return true;

}

bool PlayerManager::CheckSetAdminName(int index, CPlayer *pPlayer, AdminId id)

{

	const char *password = g_Admins.GetAdminPassword(id);

	if (password == NULL)

	{

		return false;

	}

	if (m_PassInfoVar.size() < 1)

	{

		return false;

	}

	/* Whoa... the user needs a password! */

	const char *given = engine->GetClientConVarValue(index, m_PassInfoVar.c_str());

	if (!given || strcmp(given, password) != 0)

	{

		return false;

	}

	pPlayer->SetAdminId(id, false);

	return true;

}

void PlayerManager::RunAuthChecks()

{

	CPlayer *pPlayer;

	const char *authstr;

	unsigned int removed = 0;

	for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

	{

		pPlayer = &m_Players[m_AuthQueue[i]];

		authstr = engine->GetPlayerNetworkIDString(pPlayer->m_pEdict);

#if SOURCE_ENGINE >= SE_ORANGEBOX

		// we can only easily check if the client is fully authed if we're on a recent engine

		if (m_bUseSteamAdminAuth && !g_HL2.IsLANServer())

		{

			if (!pPlayer->IsAuthedBySteam())

			{

				continue; // we're using steam auth, and steam doesn't know about this player yet so we can't do anything about them for now

			}

		}

#endif

		if (authstr && authstr[0] != '\0'

			&& (strcmp(authstr, "STEAM_ID_PENDING") != 0))

		{

			/* Set authorization */

			pPlayer->Authorize(authstr);

			/* Mark as removed from queue */

			unsigned int client = m_AuthQueue[i];

			m_AuthQueue[i] = 0;

			removed++;

			/* Send to extensions */

			List<IClientListener *>::iterator iter;

			IClientListener *pListener;

			for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

			{

				pListener = (*iter);

				pListener->OnClientAuthorized(client, authstr);

				if (!pPlayer->IsConnected())

				{

					break;

				}

			}

			/* Send to plugins if player is still connected */

			if (pPlayer->IsConnected() && m_clauth->GetFunctionCount())

			{

				/* :TODO: handle the case of a player disconnecting in the middle */

				m_clauth->PushCell(client);

				m_clauth->PushString(authstr);

				m_clauth->Execute(NULL);

			}

			if (pPlayer->IsConnected())

			{

				pPlayer->Authorize_Post();

			}

		}

	}

	/* Clean up the queue */

	if (removed)

	{

		/* We don't have to compact the list if it's empty */

		if (removed != m_AuthQueue[0])

		{

			unsigned int diff = 0;

			for (unsigned int i=1; i<=m_AuthQueue[0]; i++)

			{

				/* If this member is removed... */

				if (m_AuthQueue[i] == 0)

				{

					/* Increase the differential */

					diff++;

				} else {

					/* diff cannot increase faster than i+1 */

					assert(i > diff);

					assert(i - diff >= 1);

					/* move this index down */

					m_AuthQueue[i - diff] = m_AuthQueue[i];

				}

			}

			m_AuthQueue[0] -= removed;

		} else {

			m_AuthQueue[0] = 0;

		}

	}

}

bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

{

	int client = IndexOfEdict(pEntity);

	CPlayer *pPlayer = &m_Players[client];

	++m_PlayersSinceActive;

	pPlayer->Initialize(pszName, pszAddress, pEntity);

	/* Get the client's language */

	if (m_QueryLang)

	{

		const char *name;

		if (!pPlayer->IsFakeClient() && (name=engine->GetClientConVarValue(client, "cl_language")))

		{

			unsigned int langid;

			pPlayer->m_LangId = (translator->GetLanguageByName(name, &langid)) ? langid : translator->GetServerLanguage();

		} else {

			pPlayer->m_LangId = translator->GetServerLanguage();

		}

	}

	List<IClientListener *>::iterator iter;

	IClientListener *pListener = NULL;

	for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

	{

		pListener = (*iter);

		if (!pListener->InterceptClientConnect(client, reject, maxrejectlen))

		{

			RETURN_META_VALUE(MRES_SUPERCEDE, false);

		}

	}

	cell_t res = 1;

	m_clconnect->PushCell(client);

	m_clconnect->PushStringEx(reject, maxrejectlen, SM_PARAM_STRING_UTF8 | SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);

	m_clconnect->PushCell(maxrejectlen);

	m_clconnect->Execute(&res);

	if (res)

	{

		if (!pPlayer->IsAuthorized())

		{

			m_AuthQueue[++m_AuthQueue[0]] = client;

		}

		m_UserIdLookUp[engine->GetPlayerUserId(pEntity)] = client;

	}

	else

	{

		if (!pPlayer->IsFakeClient())

		{

			RETURN_META_VALUE(MRES_SUPERCEDE, false);

		}

	}

	return true;

}

bool PlayerManager::OnClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen)

{

	int client = IndexOfEdict(pEntity);

	bool orig_value = META_RESULT_ORIG_RET(bool);

	CPlayer *pPlayer = &m_Players[client];

	if (orig_value)

	{

		List<IClientListener *>::iterator iter;

		IClientListener *pListener = NULL;

		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)

		{

			pListener = (*iter);

			pListener->OnClientConnected(client);

			if (!pPlayer->IsConnected())

			{

				return true;

			}

		}

		if (!pPlayer->IsFakeClient() 

			&& m_bIsListenServer

			&& strncmp(pszAddress, "127.0.0.1", 9) == 0)