/**

 * vim: set ts=4 :

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

 * SourceMod

 * Copyright (C) 2004-2007 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 "ConCmdManager.h"

#include "sm_srvcmds.h"

#include "AdminCache.h"

#include "sm_stringutil.h"

#include "PlayerManager.h"

#include "Translator.h"

#include "HalfLife2.h"

#include "ChatTriggers.h"

ConCmdManager g_ConCmds;

#if defined ORANGEBOX_BUILD

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

#else

	SH_DECL_HOOK0_void(ConCommand, Dispatch, SH_NOATTRIB, false);

#endif

SH_DECL_HOOK1_void(IServerGameClients, SetCommandClient, SH_NOATTRIB, false, int);

struct PlCmdInfo

{

	ConCmdInfo *pInfo;

	CmdHook *pHook;

	CmdType type;

};

typedef List<PlCmdInfo> CmdList;

void AddToPlCmdList(CmdList *pList, const PlCmdInfo &info);

ConCmdManager::ConCmdManager() : m_Strings(1024)

{

	m_pCmds = sm_trie_create();

	m_pCmdGrps = sm_trie_create();

	m_CmdClient = 0;

}

ConCmdManager::~ConCmdManager()

{

	sm_trie_destroy(m_pCmds);

	sm_trie_destroy(m_pCmdGrps);

}

void ConCmdManager::OnSourceModAllInitialized()

{

	g_PluginSys.AddPluginsListener(this);

	g_RootMenu.AddRootConsoleCommand("cmds", "List console commands", this);

	SH_ADD_HOOK_MEMFUNC(IServerGameClients, SetCommandClient, serverClients, this, &ConCmdManager::SetCommandClient, false);

}

void ConCmdManager::OnSourceModShutdown()

{

	/* All commands should already be removed by the time we're done */

	SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, SetCommandClient, serverClients, this, &ConCmdManager::SetCommandClient, false);

	g_RootMenu.RemoveRootConsoleCommand("cmds", this);

}

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

{

	/* Whoa, first get its information struct */

	ConCmdInfo *pInfo;

	if (!sm_trie_retrieve(m_pCmds, name, (void **)&pInfo))

	{

		return;

	}

	RemoveConCmds(pInfo->srvhooks);

	RemoveConCmds(pInfo->conhooks);

	RemoveConCmd(pInfo, name, is_read_safe, false);

}

void ConCmdManager::RemoveConCmds(List<CmdHook *> &cmdlist)

{

	List<CmdHook *>::iterator iter = cmdlist.begin();

	while (iter != cmdlist.end())

	{

		CmdHook *pHook = (*iter);

		IPluginContext *pContext = pHook->pf->GetParentContext();

		IPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pContext->GetContext());

		CmdList *pList = NULL;

		//gaben

		if (!pPlugin->GetProperty("CommandList", (void **)&pList, false) || !pList)

		{

			continue;

		}

		CmdList::iterator p_iter = pList->begin();

		while (p_iter != pList->end())

		{

			PlCmdInfo &cmd = (*p_iter);

			if (cmd.pHook == pHook)

			{

				p_iter = pList->erase(p_iter);

			}

			else

			{

				p_iter++;

			}

		}

		delete pHook->pAdmin;

		delete pHook;

		iter = cmdlist.erase(iter);

	}

}

void ConCmdManager::RemoveConCmds(List<CmdHook *> &cmdlist, IPluginContext *pContext)

{

	List<CmdHook *>::iterator iter = cmdlist.begin();

	CmdHook *pHook;

	while (iter != cmdlist.end())

	{

		pHook = (*iter);

		if (pHook->pf->GetParentContext() == pContext)

		{

			delete pHook->pAdmin;

			delete pHook;

			iter = cmdlist.erase(iter);

		}

		else

		{

			iter++;

		}

	}

}

void ConCmdManager::OnPluginDestroyed(IPlugin *plugin)

{

	CmdList *pList;

	List<ConCmdInfo *> removed;

	if (plugin->GetProperty("CommandList", (void **)&pList, true))

	{

		IPluginContext *pContext = plugin->GetBaseContext();

		CmdList::iterator iter;

		/* First pass!

	 	 * Only bother if there's an actual command list on this plugin... 

	 	 */

		for (iter=pList->begin();

			iter!=pList->end();

			iter++)

		{

			PlCmdInfo &cmd = (*iter);

			ConCmdInfo *pInfo = cmd.pInfo;

			/* Has this chain already been fully cleaned/removed? */

			if (removed.find(pInfo) != removed.end())

			{

				continue;

			}

			/* Remove any hooks from us on this command */

			RemoveConCmds(pInfo->conhooks, pContext);

			RemoveConCmds(pInfo->srvhooks, pContext);

			/* See if there are still hooks */

			if (pInfo->srvhooks.size())

			{

				continue;

			}

			if (pInfo->conhooks.size())

			{

				continue;

			}

			/* Remove the command, it should be safe now */

			RemoveConCmd(pInfo, pInfo->pCmd->GetName(), true, true);

			removed.push_back(pInfo);

		}

		delete pList;

	}

}

#if defined ORANGEBOX_BUILD

void CommandCallback(const CCommand &command)

{

#else

void CommandCallback()

{

	CCommand command;

#endif

	g_HL2.PushCommandStack(&command);

	g_ConCmds.InternalDispatch(command);

	g_HL2.PopCommandStack();

}

void ConCmdManager::SetCommandClient(int client)

{

	m_CmdClient = client + 1;

}

ResultType ConCmdManager::DispatchClientCommand(int client, const char *cmd, int args, ResultType type)

{

	ConCmdInfo *pInfo;

	if (sm_trie_retrieve(m_pCmds, cmd, (void **)&pInfo))

	{

		cell_t result = type;

		cell_t tempres = result;

		List<CmdHook *>::iterator iter;

		CmdHook *pHook;

		for (iter=pInfo->conhooks.begin();

			 iter!=pInfo->conhooks.end();

			 iter++)

		{

			pHook = (*iter);

			if (!pHook->pf->IsRunnable())

			{

				continue;

			}

			if (pHook->pAdmin && !CheckAccess(client, cmd, pHook->pAdmin))

			{

				if (result < Pl_Handled)

				{

					result = Pl_Handled;

				}

				continue;

			}

			pHook->pf->PushCell(client);

			pHook->pf->PushCell(args);

			if (pHook->pf->Execute(&tempres) == SP_ERROR_NONE)

			{

				if (tempres > result)

				{

					result = tempres;

				}

				if (result == Pl_Stop)

				{

					break;

				}

			}

		}

		type = (ResultType)result;

	}

	return type;

}

void ConCmdManager::InternalDispatch(const CCommand &command)

{

	int client = m_CmdClient;

	if (client)

	{

		CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);

		if (!pPlayer || !pPlayer->IsConnected())

		{

			return;

		}

	}

	/**

	 * Note: Console commands will EITHER go through IServerGameDLL::ClientCommand,

	 * OR this dispatch.  They will NEVER go through both.

	 * -- 

	 * Whether or not it goes through the callback is determined by FCVAR_GAMEDLL

	 */

	const char *cmd = g_HL2.CurrentCommandName();

	ConCmdInfo *pInfo;

	if (!sm_trie_retrieve(m_pCmds, cmd, (void **)&pInfo))

	{

		return;

	}

	cell_t result = Pl_Continue;

	int args = command.ArgC() - 1;

	List<CmdHook *>::iterator iter;

	CmdHook *pHook;

	/* Execute server-only commands if viable */

	if (client == 0 && pInfo->srvhooks.size())

	{

		cell_t tempres = result;

		for (iter=pInfo->srvhooks.begin();

			 iter!=pInfo->srvhooks.end();

			 iter++)

		{

			pHook = (*iter);

			if (!pHook->pf->IsRunnable())

			{

				continue;

			}

			pHook->pf->PushCell(args);

			if (pHook->pf->Execute(&tempres) == SP_ERROR_NONE)

			{

				if (tempres > result)

				{

					result = tempres;

				}

				if (result == Pl_Stop)

				{

					break;

				}

			}

		}

		/* Check if there's an early stop */

		if (result >= Pl_Stop)

		{

			if (!pInfo->sourceMod)

			{

				RETURN_META(MRES_SUPERCEDE);

			}

			return;

		}

	}

	/* Execute console commands */

	if (pInfo->conhooks.size())

	{

		cell_t tempres = result;

		for (iter=pInfo->conhooks.begin();

			iter!=pInfo->conhooks.end();

			iter++)

		{

			pHook = (*iter);

			if (!pHook->pf->IsRunnable())

			{

				continue;

			}

			if (client 

				&& pHook->pAdmin

				&& !CheckAccess(client, cmd, pHook->pAdmin))

			{

				if (result < Pl_Handled)

				{

					result = Pl_Handled;

				}

				continue;

			}

			/* On a listen server, sometimes the server host's client index can be set as 0.

			 * So index 1 is passed to the command callback to correct this potential problem.

			 */

			if (client == 0 && !engine->IsDedicatedServer())

			{

				pHook->pf->PushCell(1);

			} else {

				pHook->pf->PushCell(client);

			}

			pHook->pf->PushCell(args);

			if (pHook->pf->Execute(&tempres) == SP_ERROR_NONE)

			{

				if (tempres > result)

				{

					result = tempres;

				}

				if (result == Pl_Stop)

				{

					break;

				}

			}

		}

	}

	if (result >= Pl_Handled)

	{

		if (!pInfo->sourceMod)

		{

			RETURN_META(MRES_SUPERCEDE);

		}

		return;

	}

}

bool ConCmdManager::CheckCommandAccess(int client, const char *cmd, FlagBits cmdflags)

{

	if (cmdflags == 0 || client == 0)

	{

		return true;

	}

	/* If running listen server, then client 1 is the server host and should have 'root' access */

	if (client == 1 && !engine->IsDedicatedServer())

	{

		return true;

	}

	CPlayer *player = g_Players.GetPlayerByIndex(client);

	if (!player 

		|| player->GetEdict() == NULL

		|| player->IsFakeClient())

	{

		return false;

	}

	AdminId adm = player->GetAdminId();

	if (adm != INVALID_ADMIN_ID)

	{

		FlagBits bits = g_Admins.GetAdminFlags(adm, Access_Effective);

		/* root knows all, WHOA */

		if ((bits & ADMFLAG_ROOT) == ADMFLAG_ROOT)

		{

			return true;

		}

		/* Check for overrides

		 * :TODO: is it worth optimizing this?

		 */

		unsigned int groups = g_Admins.GetAdminGroupCount(adm);

		GroupId gid;

		OverrideRule rule;

		bool override = false;

		for (unsigned int i=0; i<groups; i++)

		{

			gid = g_Admins.GetAdminGroup(adm, i, NULL);

			/* First get group-level override */

			override = g_Admins.GetGroupCommandOverride(gid, cmd, Override_CommandGroup, &rule);

			/* Now get the specific command override */

			if (g_Admins.GetGroupCommandOverride(gid, cmd, Override_Command, &rule))

			{

				override = true;

			}

			if (override)

			{

				if (rule == Command_Allow)

				{

					return true;

				} else if (rule == Command_Deny) {

					return false;

				}

			}

		}

		/* See if our other flags match */

		if ((bits & cmdflags) == cmdflags)

		{

			return true;

		}

	}

	return false;

}

bool ConCmdManager::CheckAccess(int client, const char *cmd, AdminCmdInfo *pAdmin)

{

	if (CheckCommandAccess(client, cmd, pAdmin->eflags))

	{

		return true;

	}

	edict_t *pEdict = engine->PEntityOfEntIndex(client);

	/* If we got here, the command failed... */

	char buffer[128];

	if (g_Translator.CoreTrans(client, buffer, sizeof(buffer), "No Access", NULL, NULL)

		!= Trans_Okay)

	{

		snprintf(buffer, sizeof(buffer), "You do not have access to this command");

	}

	unsigned int replyto = g_ChatTriggers.GetReplyTo();

	if (replyto == SM_REPLY_CONSOLE)

	{

		char fullbuffer[192];

		snprintf(fullbuffer, sizeof(fullbuffer), "[SM] %s.\n", buffer);

		engine->ClientPrintf(pEdict, fullbuffer);

	} else if (replyto == SM_REPLY_CHAT) {

		char fullbuffer[192];

		snprintf(fullbuffer, sizeof(fullbuffer), "[SM] %s.", buffer);

		g_HL2.TextMsg(client, HUD_PRINTTALK, fullbuffer);

	}

	return false;

}

bool ConCmdManager::AddConsoleCommand(IPluginFunction *pFunction, 

									   const char *name, 

									   const char *description, 

									   int flags)

{

	ConCmdInfo *pInfo = AddOrFindCommand(name, description, flags);

	if (!pInfo)

	{

		return false;

	}

	CmdHook *pHook = new CmdHook();

	pHook->pf = pFunction;

	if (description && description[0])

	{

		pHook->helptext.assign(description);

	}

	pInfo->conhooks.push_back(pHook);

	/* Add to the plugin */

	CmdList *pList;

	IPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pFunction->GetParentContext()->GetContext());

	if (!pPlugin->GetProperty("CommandList", (void **)&pList))

	{

		pList = new CmdList();

		pPlugin->SetProperty("CommandList", pList);

	}

	PlCmdInfo info;

	info.pInfo = pInfo;

	info.type = Cmd_Console;

	info.pHook = pHook;

	AddToPlCmdList(pList, info);

	return true;

}

bool ConCmdManager::AddAdminCommand(IPluginFunction *pFunction, 

									 const char *name, 

									 const char *group,

									 int adminflags,

									 const char *description, 

									 int flags)

{

	ConCmdInfo *pInfo = AddOrFindCommand(name, description, flags);

	if (!pInfo)

	{

		return false;

	}

	CmdHook *pHook = new CmdHook();

	AdminCmdInfo *pAdmin = new AdminCmdInfo();

	pHook->pf = pFunction;

	if (description && description[0])

	{

		pHook->helptext.assign(description);

	}

	pHook->pAdmin = pAdmin;

	void *object;

	int grpid;

	if (!sm_trie_retrieve(m_pCmdGrps, group, (void **)&object))

	{

		grpid = m_Strings.AddString(group);

		sm_trie_insert(m_pCmdGrps, group, (void *)grpid);

	}

	else

	{

		grpid = (int)object;

	}

	pAdmin->cmdGrpId = grpid;

	pAdmin->flags = adminflags;

	/* First get the command group override, if any */

	bool override = g_Admins.GetCommandOverride(group, 

		Override_CommandGroup,

		&(pAdmin->eflags));

	/* Next get the command override, if any */

	if (g_Admins.GetCommandOverride(name,

		Override_Command,

		&(pAdmin->eflags)))

	{

		override = true;