/**

 * 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>.

 */

#include "ConVarManager.h"

#include "HalfLife2.h"

#include "ForwardSys.h"

#include "sm_srvcmds.h"

#include "sm_stringutil.h"

#include <sh_vector.h>

#include <sm_trie_tpl.h>

#include "logic_bridge.h"

ConVarManager g_ConVarManager;

#if SOURCE_ENGINE >= SE_ORANGEBOX

SH_DECL_HOOK3_void(ICvar, CallGlobalChangeCallbacks, SH_NOATTRIB, false, ConVar *, const char *, float);

#else

SH_DECL_HOOK2_void(ICvar, CallGlobalChangeCallback, SH_NOATTRIB, false, ConVar *, const char *);

#endif

#if SOURCE_ENGINE != SE_DARKMESSIAH

SH_DECL_HOOK5_void(IServerGameDLL, OnQueryCvarValueFinished, SH_NOATTRIB, 0, QueryCvarCookie_t, edict_t *, EQueryCvarValueStatus, const char *, const char *);

SH_DECL_HOOK5_void(IServerPluginCallbacks, OnQueryCvarValueFinished, SH_NOATTRIB, 0, QueryCvarCookie_t, edict_t *, EQueryCvarValueStatus, const char *, const char *);

#endif

const ParamType CONVARCHANGE_PARAMS[] = {Param_Cell, Param_String, Param_String};

typedef List<const ConVar *> ConVarList;

KTrie<ConVarInfo *> convar_cache;

class ConVarReentrancyGuard

{

	ConVar *cvar;

	ConVarReentrancyGuard *up;

public:

	static ConVarReentrancyGuard *chain;

	ConVarReentrancyGuard(ConVar *cvar)

		: cvar(cvar), up(chain)

	{

		chain = this;

	}

	~ConVarReentrancyGuard()

	{

		assert(chain == this);

		chain = up;

	}

	static bool IsCvarInChain(ConVar *cvar)

	{

		ConVarReentrancyGuard *guard = chain;

		while (guard != NULL)

		{

			if (guard->cvar == cvar)

				return true;

			guard = guard->up;

		}

		return false;

	}

};

ConVarReentrancyGuard *ConVarReentrancyGuard::chain = NULL;

ConVarManager::ConVarManager() : m_ConVarType(0), m_bIsDLLQueryHooked(false), m_bIsVSPQueryHooked(false)

{

}

ConVarManager::~ConVarManager()

{

}

void ConVarManager::OnSourceModStartup(bool late)

{

	HandleAccess sec;

	/* Set up access rights for the 'ConVar' handle type */

	sec.access[HandleAccess_Read] = 0;

	sec.access[HandleAccess_Delete] = HANDLE_RESTRICT_IDENTITY | HANDLE_RESTRICT_OWNER;

	sec.access[HandleAccess_Clone] = HANDLE_RESTRICT_IDENTITY | HANDLE_RESTRICT_OWNER;

	/* Create the 'ConVar' handle type */

	m_ConVarType = handlesys->CreateType("ConVar", this, 0, NULL, &sec, g_pCoreIdent, NULL);

}

void ConVarManager::OnSourceModAllInitialized()

{

	/**

	 * Episode 2 has this function by default, but the older versions do not.

	 */

#if SOURCE_ENGINE == SE_EPISODEONE

	if (g_SMAPI->GetGameDLLVersion() >= 6)

	{

		SH_ADD_HOOK(IServerGameDLL, OnQueryCvarValueFinished, gamedll, SH_MEMBER(this, &ConVarManager::OnQueryCvarValueFinished), false);

		m_bIsDLLQueryHooked = true;

	}

#endif

#if SOURCE_ENGINE >= SE_ORANGEBOX

	SH_ADD_HOOK(ICvar, CallGlobalChangeCallbacks, icvar, SH_STATIC(OnConVarChanged), false);

#else

	SH_ADD_HOOK(ICvar, CallGlobalChangeCallback, icvar, SH_STATIC(OnConVarChanged), false);

#endif

	scripts->AddPluginsListener(this);

	/* Add the 'convars' option to the 'sm' console command */

	g_RootMenu.AddRootConsoleCommand("cvars", "View convars created by a plugin", this);

}

void ConVarManager::OnSourceModShutdown()

{

	List<ConVarInfo *>::iterator iter = m_ConVars.begin();

	HandleSecurity sec(NULL, g_pCoreIdent);

	/* Iterate list of ConVarInfo structures, remove every one of them */

	while (iter != m_ConVars.end())

	{

		ConVarInfo *pInfo = (*iter);

		iter = m_ConVars.erase(iter);

		handlesys->FreeHandle(pInfo->handle, &sec);

		if (pInfo->pChangeForward != NULL)

		{

			g_Forwards.ReleaseForward(pInfo->pChangeForward);

		}

		if (pInfo->sourceMod)

		{

			/* If we created it, we won't be tracking it, therefore it is 

			 * safe to remove everything in one go.

			 */

			META_UNREGCVAR(pInfo->pVar);

			delete [] pInfo->pVar->GetName();

			delete [] pInfo->pVar->GetHelpText();

			delete [] pInfo->pVar->GetDefault();

			delete pInfo->pVar;

		}

		else

		{

			/* If we didn't create it, we might be tracking it.  Also, 

			 * it could be unreadable.

			 */

			UntrackConCommandBase(pInfo->pVar, this);

		}

		/* It's not safe to read the name here, so we simply delete the 

		 * the info struct and clear the lookup cache at the end.

		 */

		delete pInfo;

	}

	convar_cache.clear();

#if SOURCE_ENGINE != SE_DARKMESSIAH

	/* Unhook things */

	if (m_bIsDLLQueryHooked)

	{

		SH_REMOVE_HOOK(IServerGameDLL, OnQueryCvarValueFinished, gamedll, SH_MEMBER(this, &ConVarManager::OnQueryCvarValueFinished), false);

		m_bIsDLLQueryHooked = false;

	}

	else if (m_bIsVSPQueryHooked)

	{

		SH_REMOVE_HOOK(IServerPluginCallbacks, OnQueryCvarValueFinished, vsp_interface, SH_MEMBER(this, &ConVarManager::OnQueryCvarValueFinished), false);

		m_bIsVSPQueryHooked = false;

	}

#endif

#if SOURCE_ENGINE >= SE_ORANGEBOX

	SH_REMOVE_HOOK(ICvar, CallGlobalChangeCallbacks, icvar, SH_STATIC(OnConVarChanged), false);

#else

	SH_REMOVE_HOOK(ICvar, CallGlobalChangeCallback, icvar, SH_STATIC(OnConVarChanged), false);

#endif

	/* Remove the 'convars' option from the 'sm' console command */

	g_RootMenu.RemoveRootConsoleCommand("cvars", this);

	scripts->RemovePluginsListener(this);

	/* Remove the 'ConVar' handle type */

	handlesys->RemoveType(m_ConVarType, g_pCoreIdent);

}

/**

 * Orange Box will never use this.

 */

void ConVarManager::OnSourceModVSPReceived()

{

	/**

	 * Don't bother if the DLL is already hooked.

	 */

	if (m_bIsDLLQueryHooked)

	{

		return;

	}

	/* For later MM:S versions, use the updated API, since it's cleaner. */

#if defined METAMOD_PLAPI_VERSION || PLAPI_VERSION >= 11

	int engine = g_SMAPI->GetSourceEngineBuild();

	if (engine == SOURCE_ENGINE_ORIGINAL || vsp_version < 2)

	{

		return;

	}

#else

	if (g_HL2.IsOriginalEngine() || vsp_version < 2)

	{

		return;

	}

#endif

#if SOURCE_ENGINE != SE_DARKMESSIAH

	SH_ADD_HOOK(IServerPluginCallbacks, OnQueryCvarValueFinished, vsp_interface, SH_MEMBER(this, &ConVarManager::OnQueryCvarValueFinished), false);

	m_bIsVSPQueryHooked = true;

#endif

}

bool convar_cache_lookup(const char *name, ConVarInfo **pVar)

{

	ConVarInfo **pLookup = convar_cache.retrieve(name);

	if (pLookup != NULL)

	{

		*pVar = *pLookup;

		return true;

	}

	else

	{

		return false;

	}

}

void ConVarManager::OnUnlinkConCommandBase(ConCommandBase *pBase, const char *name, bool is_read_safe)

{

	/* Only check convars that have not been created by SourceMod's core */

	ConVarInfo *pInfo;

	if (!convar_cache_lookup(name, &pInfo))

	{

		return;

	}

	HandleSecurity sec(NULL, g_pCoreIdent);

	/* Remove it from our cache */

	m_ConVars.remove(pInfo);

	convar_cache.remove(name);

	/* Now make sure no plugins are referring to this pointer */

	IPluginIterator *pl_iter = scripts->GetPluginIterator();

	while (pl_iter->MorePlugins())

	{

		IPlugin *pl = pl_iter->GetPlugin();

		ConVarList *pConVarList;

		if (pl->GetProperty("ConVarList", (void **)&pConVarList, true) 

			&& pConVarList != NULL)

		{

			pConVarList->remove(pInfo->pVar);

		}

		pl_iter->NextPlugin();

	}

	/* Free resources */

	handlesys->FreeHandle(pInfo->handle, &sec);

	delete pInfo;

}

void ConVarManager::OnPluginUnloaded(IPlugin *plugin)

{

	ConVarList *pConVarList;

	List<ConVarQuery>::iterator iter;

	/* If plugin has a convar list, free its memory */

	if (plugin->GetProperty("ConVarList", (void **)&pConVarList, true))

	{

		delete pConVarList;

	}

	/* Remove convar queries for this plugin that haven't returned results yet */

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

	{

		ConVarQuery &query = (*iter);

		if (query.pCallback->GetParentRuntime() == plugin->GetRuntime())

		{

			m_ConVarQueries.erase(iter);

		}

	}

}

void ConVarManager::OnHandleDestroy(HandleType_t type, void *object)

{

}

bool ConVarManager::GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)

{

	*pSize = sizeof(ConVar) + sizeof(ConVarInfo);

	return true;

}

void ConVarManager::OnRootConsoleCommand(const char *cmdname, const CCommand &command)

{

	int argcount = command.ArgC();

	if (argcount >= 3)

	{

		bool wantReset = false;

		/* Get plugin index that was passed */

		const char *arg = command.Arg(2);

		if (argcount >= 4 && strcmp(arg, "reset") == 0)

		{

			wantReset = true;

			arg = command.Arg(3);

		}

		/* Get plugin object */

		IPlugin *plugin = scripts->FindPluginByConsoleArg(arg);

		if (!plugin)

		{

			g_RootMenu.ConsolePrint("[SM] Plugin \"%s\" was not found.", arg);

			return;

		}

		/* Get plugin name */

		const sm_plugininfo_t *plinfo = plugin->GetPublicInfo();

		const char *plname = IS_STR_FILLED(plinfo->name) ? plinfo->name : plugin->GetFilename();

		ConVarList *pConVarList;

		ConVarList::iterator iter;

		/* If no convar list... */

		if (!plugin->GetProperty("ConVarList", (void **)&pConVarList))

		{

			g_RootMenu.ConsolePrint("[SM] No convars found for: %s", plname);

			return;

		}

		if (!wantReset)

		{

			g_RootMenu.ConsolePrint("[SM] Listing %d convars for: %s", pConVarList->size(), plname);

			g_RootMenu.ConsolePrint("  %-32.31s %s", "[Name]", "[Value]");

		}

		/* Iterate convar list and display/reset each one */

		for (iter = pConVarList->begin(); iter != pConVarList->end(); iter++)

		{

			/*const */ConVar *pConVar = const_cast<ConVar *>(*iter);

			if (!wantReset)

			{

				g_RootMenu.ConsolePrint("  %-32.31s %s", pConVar->GetName(), pConVar->GetString()); 

			} else {

				pConVar->Revert();

			}

		}

		if (wantReset)

		{

			g_RootMenu.ConsolePrint("[SM] Reset %d convars for: %s", pConVarList->size(), plname);

		}

		return;

	}

	/* Display usage of subcommand */

	g_RootMenu.ConsolePrint("[SM] Usage: sm cvars [reset] <plugin #>");

}

Handle_t ConVarManager::CreateConVar(IPluginContext *pContext, const char *name, const char *defaultVal, const char *description, int flags, bool hasMin, float min, bool hasMax, float max)

{

	ConVar *pConVar = NULL;

	ConVarInfo *pInfo = NULL;

	Handle_t hndl = 0;

	/* Find out if the convar exists already */

	pConVar = icvar->FindVar(name);

	/* If the convar already exists... */

	if (pConVar)

	{

		/* Add convar to plugin's list */

		AddConVarToPluginList(pContext, pConVar);

		/* First find out if we already have a handle to it */

		if (convar_cache_lookup(name, &pInfo))

		{

			return pInfo->handle;

		}

		else

		{

			/* Create and initialize ConVarInfo structure */

			pInfo = new ConVarInfo();

			pInfo->sourceMod = false;

			pInfo->pChangeForward = NULL;

			pInfo->pVar = pConVar;

			/* If we don't, then create a new handle from the convar */

			hndl = handlesys->CreateHandle(m_ConVarType, pInfo, NULL, g_pCoreIdent, NULL);

			if (hndl == BAD_HANDLE)

			{

				delete pInfo;

				return BAD_HANDLE;

			}

			pInfo->handle = hndl;

			/* Insert struct into caches */

			m_ConVars.push_back(pInfo);

			convar_cache.insert(name, pInfo);

			TrackConCommandBase(pConVar, this);

			return hndl;

		}

	}

	/* Prevent creating a convar that has the same name as a console command */

	if (FindCommand(name))

	{

		return BAD_HANDLE;

	}

	/* Create and initialize ConVarInfo structure */

	pInfo = new ConVarInfo();

	pInfo->handle = hndl;

	pInfo->sourceMod = true;

	pInfo->pChangeForward = NULL;

	/* Create a handle from the new convar */

	hndl = handlesys->CreateHandle(m_ConVarType, pInfo, NULL, g_pCoreIdent, NULL);

	if (hndl == BAD_HANDLE)

	{

		delete pInfo;

		return BAD_HANDLE;

	}

	pInfo->handle = hndl;

	/* Since an existing convar (or concmd with the same name) was not found , now we can finally create it */

	pConVar = new ConVar(sm_strdup(name), sm_strdup(defaultVal), flags, sm_strdup(description), hasMin, min, hasMax, max);

	pInfo->pVar = pConVar;

	/* Add convar to plugin's list */

	AddConVarToPluginList(pContext, pConVar);

	/* Insert struct into caches */

	m_ConVars.push_back(pInfo);

	convar_cache.insert(name, pInfo);

	return hndl;

}

Handle_t ConVarManager::FindConVar(const char *name)

{

	ConVar *pConVar = NULL;

	ConVarInfo *pInfo;

	Handle_t hndl;

	/* Search for convar */

	pConVar = icvar->FindVar(name);

	/* If it doesn't exist, then return an invalid handle */

	if (!pConVar)

	{

		return BAD_HANDLE;

	}

	/* At this point, the convar exists. So, find out if we already have a handle */

	if (convar_cache_lookup(name, &pInfo))

	{

		return pInfo->handle;

	}

	/* Create and initialize ConVarInfo structure */

	pInfo = new ConVarInfo();

	pInfo->sourceMod = false;

	pInfo->pChangeForward = NULL;

	pInfo->pVar = pConVar;

	/* If we don't have a handle, then create a new one */

	hndl = handlesys->CreateHandle(m_ConVarType, pInfo, NULL, g_pCoreIdent, NULL);

	if (hndl == BAD_HANDLE)

	{

		delete pInfo;

		return BAD_HANDLE;

	}

	pInfo->handle = hndl;

	/* Insert struct into our caches */

	m_ConVars.push_back(pInfo);

	convar_cache.insert(name, pInfo);

	TrackConCommandBase(pConVar, this);

	return hndl;

}

void ConVarManager::AddConVarChangeListener(const char *name, IConVarChangeListener *pListener)

{

	ConVarInfo *pInfo;

	if (FindConVar(name) == BAD_HANDLE)

	{

		return;

	}

	/* Find the convar in the lookup trie */

	if (convar_cache_lookup(name, &pInfo))

	{

		pInfo->changeListeners.push_back(pListener);

	}

}

void ConVarManager::RemoveConVarChangeListener(const char *name, IConVarChangeListener *pListener)

{

	ConVarInfo *pInfo;

	/* Find the convar in the lookup trie */

	if (convar_cache_lookup(name, &pInfo))

	{

		pInfo->changeListeners.remove(pListener);

	}

}

void ConVarManager::HookConVarChange(ConVar *pConVar, IPluginFunction *pFunction)

{

	ConVarInfo *pInfo;

	IChangeableForward *pForward;

	/* Find the convar in the lookup trie */

	if (convar_cache_lookup(pConVar->GetName(), &pInfo))

	{

		/* Get the forward */

		pForward = pInfo->pChangeForward;

		/* If forward does not exist, create it */

		if (!pForward)

		{

			pForward = g_Forwards.CreateForwardEx(NULL, ET_Ignore, 3, CONVARCHANGE_PARAMS);

			pInfo->pChangeForward = pForward;

		}

		/* Add function to forward's list */

		pForward->AddFunction(pFunction);

	}

}

void ConVarManager::UnhookConVarChange(ConVar *pConVar, IPluginFunction *pFunction)

{

	ConVarInfo *pInfo;

	IChangeableForward *pForward;

	IPluginContext *pContext = pFunction->GetParentContext();

	/* Find the convar in the lookup trie */

	if (convar_cache_lookup(pConVar->GetName(), &pInfo))

	{

		/* Get the forward */

		pForward = pInfo->pChangeForward;

		/* If the forward doesn't exist, we can't unhook anything */

		if (!pForward)

		{

			pContext->ThrowNativeError("Convar \"%s\" has no active hook", pConVar->GetName());

			return;

		}

		/* Remove the function from the forward's list */

		if (!pForward->RemoveFunction(pFunction))

		{

			pContext->ThrowNativeError("Invalid hook callback specified for convar \"%s\"", pConVar->GetName());

			return;

		}

		/* If the forward now has 0 functions in it... */

		if (pForward->GetFunctionCount() == 0 &&

			!ConVarReentrancyGuard::IsCvarInChain(pConVar))

		{

			/* Free this forward */

			g_Forwards.ReleaseForward(pForward);