/**

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

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

  * SourceMod

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

 #include "ChatTriggers.h"

 #include "logic_bridge.h"

 using namespace ke;

 ConCmdManager g_ConCmds;

 #if SOURCE_ENGINE == SE_DOTA

 	SH_DECL_HOOK2_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommandContext &, const CCommand &);

 #elif SOURCE_ENGINE >= SE_ORANGEBOX

 	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);

 typedef ke::LinkedList<CmdHook *> PluginHookList;

 void RegisterInPlugin(CmdHook *hook);

 ConCmdManager::ConCmdManager()

 {

 	m_CmdClient = 0;

 }

 ConCmdManager::~ConCmdManager()

 {

 }

 void ConCmdManager::OnSourceModAllInitialized()

 {

 	scripts->AddPluginsListener(this);

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

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

 }

 void ConCmdManager::OnSourceModShutdown()

 {

 	scripts->RemovePluginsListener(this);

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

 	SH_REMOVE_HOOK(IServerGameClients, SetCommandClient, serverClients, SH_MEMBER(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 (!m_Cmds.retrieve(name, &pInfo))

 		return;

 	CmdHookList::iterator iter = pInfo->hooks.begin();

 	while (iter != pInfo->hooks.end())

 	{

 		CmdHook *hook = *iter;

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

 		IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());

 		// The list is guaranteed to exist.

 		PluginHookList *list;

 		pPlugin->GetProperty("CommandList", (void **)&list, false);

 		for (PluginHookList::iterator hiter = list->begin(); hiter != list->end(); hiter++)

 		{

 			if (*hiter == hook)

 			{

 				list->erase(hiter);

 				break;

 			}

 		}

 		if (hook->admin)

 			hook->admin->group->hooks.remove(hook);

 		iter = pInfo->hooks.erase(iter);

 		delete hook;

 	}

 	RemoveConCmd(pInfo, name, is_read_safe, false);

 }

 void ConCmdManager::OnPluginDestroyed(IPlugin *plugin)

 {

 	PluginHookList *pList;

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

 		return;

 	PluginHookList::iterator iter = pList->begin();

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

 	{

 		CmdHook *hook = *iter;

 		hook->info->hooks.remove(hook);

 		if (hook->admin)

 			hook->admin->group->hooks.remove(hook);

 		if (hook->info->hooks.empty())

 			RemoveConCmd(hook->info, hook->info->pCmd->GetName(), true, true);

 		iter = pList->erase(iter);

 		delete hook;

 	}

 	delete pList;

 }

 #if SOURCE_ENGINE == SE_DOTA

 void CommandCallback(const CCommandContext &context, const CCommand &command)

 {

 #elif SOURCE_ENGINE >= SE_ORANGEBOX

 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;

 }

 ConCmdInfo *ConCmdManager::FindInTrie(const char *name)

 {

 	ConCmdInfo *pInfo;

 	if (!m_Cmds.retrieve(name, &pInfo))

 		return NULL;

 	return pInfo;

 }

 ConCmdList::iterator ConCmdManager::FindInList(const char *cmd)

 {

 	List<ConCmdInfo *>::iterator iter = m_CmdList.begin();

 	while (iter != m_CmdList.end())

 	{

 		if (strcasecmp((*iter)->pCmd->GetName(), cmd) == 0)

 			break;

 		iter++;

 	}

 	return iter;

 }

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

 {

 	ConCmdInfo *pInfo;

 	if ((pInfo = FindInTrie(cmd)) == NULL)

 	{

 		ConCmdList::iterator item = FindInList(cmd);

 		if (item == m_CmdList.end())

 			return type;

 		pInfo = *item;

 	}

 	cell_t result = type;

 	for (CmdHookList::iterator iter = pInfo->hooks.begin(); iter != pInfo->hooks.end(); iter++)

 	{

 		CmdHook *hook = *iter;

 		if (hook->type == CmdHook::Server || !hook->pf->IsRunnable())

 			continue;

 		if (hook->admin && !CheckAccess(client, cmd, hook->admin))

 		{

 			if (result < Pl_Handled)

 				result = Pl_Handled;

 			continue;

 		}

 		hook->pf->PushCell(client);

 		hook->pf->PushCell(args);

 		cell_t tempres = result;

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

 		{

 			if (tempres > result)

 				result = tempres;

 			if (result == Pl_Stop)

 				break;

 		}

 	}

 	return (ResultType)result;

 }

 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 = FindInTrie(cmd);

 	if (pInfo == NULL)

 	{

         /* Unfortunately, we now have to do a slow lookup because Valve made client commands 

          * case-insensitive.  We can't even use our sortedness.

          */

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

             return;

 		ConCmdList::iterator item = FindInList(cmd);

 		if (item == m_CmdList.end())

 			return;

 		pInfo = *item;

 	}

 	/* This is a hack to prevent say triggers from firing on messages that were 

 	 * blocked because of flooding.  We won't remove this, but the hack will get 

 	 * "nicer" when we expose explicit say hooks.

 	 */

 	if (g_ChatTriggers.WasFloodedMessage())

 		return;

 	cell_t result = Pl_Continue;

 	int args = command.ArgC() - 1;

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

 	int realClient = (!engine->IsDedicatedServer() && client == 0)

 	                 ? g_Players.ListenClient()

 	                 : client;

 	int dedicatedClient = engine->IsDedicatedServer() ? 0 : g_Players.ListenClient();

 	for (CmdHookList::iterator iter = pInfo->hooks.begin(); iter != pInfo->hooks.end(); iter++)

 	{

 		CmdHook *hook = *iter;

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

 			continue;

 		if (hook->type == CmdHook::Server)

 		{

 			// Don't execute unless we're in the server console.

 			if (realClient != dedicatedClient)

 				continue;

 		} else {

 			// Check admin rights if needed. realClient isn't needed since we

 			// should bypass admin checks if client == 0 anyway.

 			if (client && hook->admin && !CheckAccess(client, cmd, hook->admin))

 			{

 				if (result < Pl_Handled)

 					result = Pl_Handled;

 				continue;

 			}

 			// Client hooks get a client argument.

 			hook->pf->PushCell(realClient);

 		}

 		hook->pf->PushCell(args);

 		cell_t tempres = result;

 		if (hook->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::CheckClientCommandAccess(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;

 	}

 	return CheckAdminCommandAccess(player->GetAdminId(), cmd, cmdflags);

 }

 bool ConCmdManager::CheckAdminCommandAccess(AdminId adm, const char *cmd, FlagBits cmdflags)

 {

 	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 (CheckClientCommandAccess(client, cmd, pAdmin->eflags))

 	{

 		return true;

 	}

 	CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);

 	if (!pPlayer)

 	{

 		return false;

 	}

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

 	char buffer[128];

 	if (!logicore.CoreTranslate(buffer, sizeof(buffer), "%T", 2, NULL, "No Access", &client))

 	{

 		UTIL_Format(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];

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

 		pPlayer->PrintToConsole(fullbuffer);

 	}

 	else if (replyto == SM_REPLY_CHAT)

 	{

 		char fullbuffer[192];

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

 		g_HL2.TextMsg(client, HUD_PRINTTALK, fullbuffer);

 	}

 	return false;

 }

 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;

 	GroupMap::Insert i = m_CmdGrps.findForAdd(group);

 	if (!i.found())

 	{

 		if (!m_CmdGrps.add(i, group))

 			return false;

 		i->value = NoAddRef(new CommandGroup());

 	}

 	Ref<CommandGroup> cmdgroup = i->value;

 	CmdHook *pHook = new CmdHook(CmdHook::Client, pInfo, pFunction, description);

 	pHook->admin = new AdminCmdInfo(cmdgroup, adminflags);

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

 	bool override = g_Admins.GetCommandOverride(group, 

 		Override_CommandGroup,

 		&(pHook->admin->eflags));

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

 	if (g_Admins.GetCommandOverride(name,

 		Override_Command,

 		&(pHook->admin->eflags)))

 	{

 		override = true;

 	}

 	/* Assign normal flags if there were no overrides */

 	if (!override)

 		pHook->admin->eflags = pHook->admin->flags;

 	pInfo->eflags = pHook->admin->eflags;

 	cmdgroup->hooks.append(pHook);

 	pInfo->hooks.append(pHook);

 	RegisterInPlugin(pHook);

 	return true;

 }

 bool ConCmdManager::AddServerCommand(IPluginFunction *pFunction, 

 									  const char *name, 

 									  const char *description, 

 									  int flags)

 {

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

 	if (!pInfo)

 		return false;

 	CmdHook *pHook = new CmdHook(CmdHook::Server, pInfo, pFunction, description);

 	pInfo->hooks.append(pHook);

 	RegisterInPlugin(pHook);

 	return true;

 }

 void RegisterInPlugin(CmdHook *hook)

 {

 	PluginHookList *pList;

 	IPlugin *pPlugin = scripts->FindPluginByContext(hook->pf->GetParentContext());

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

 	{

 		pList = new PluginHookList();

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

 	}

 	const char *orig = hook->info->pCmd->GetName();

 	/* Insert this into the help list, SORTED alphabetically. */

 	PluginHookList::iterator iter = pList->begin();

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

 	{

 		const char *cmd = (*iter)->info->pCmd->GetName();

 		if (strcmp(orig, cmd) < 0)

 		{

 			pList->insertBefore(iter, hook);

 			return;

 		}

 		iter++;

 	}

 	pList->append(hook);

 }

 void ConCmdManager::AddToCmdList(ConCmdInfo *info)

 {

 	List<ConCmdInfo *>::iterator iter = m_CmdList.begin();

 	ConCmdInfo *pInfo;

 	bool inserted = false;

 	const char *orig = NULL;

 	orig = info->pCmd->GetName();

 	/* Insert this into the help list, SORTED alphabetically. */

 	while (iter != m_CmdList.end())

 	{

 		const char *cmd = NULL;

 		pInfo = (*iter);

 		cmd = pInfo->pCmd->GetName();

 		if (strcmp(orig, cmd) < 0)

 		{

 			m_CmdList.insert(iter, info);

 			inserted = true;

 			break;

 		}

 		iter++;

 	}

 	if (!inserted)

 	{

 		m_CmdList.push_back(info);

 	}

 }

 void ConCmdManager::UpdateAdminCmdFlags(const char *cmd, OverrideType type, FlagBits bits, bool remove)

 {

 	if (type == Override_Command)

 	{

 		ConCmdInfo *pInfo;

 		if (!m_Cmds.retrieve(cmd, &pInfo))

 			return;

 		for (CmdHookList::iterator iter = pInfo->hooks.begin(); iter != pInfo->hooks.end(); iter++)

 		{

 			if (!iter->admin)

 				continue;

 			if (!remove)

 				iter->admin->eflags = bits;

 			else

 				iter->admin->eflags = iter->admin->flags;

 			pInfo->eflags = iter->admin->eflags;

 		}

 	}

 	else if (type == Override_CommandGroup)

 	{

 		GroupMap::Result r = m_CmdGrps.find(cmd);

 		if (!r.found())

 			return;

 		Ref<CommandGroup> group(r->value);

 		for (PluginHookList::iterator iter = group->hooks.begin(); iter != group->hooks.end(); iter++)

 		{

 			CmdHook *hook = *iter;

 			if (remove)

 				hook->admin->eflags = bits;

 			else

 				hook->admin->eflags = hook->admin->flags;

 			hook->info->eflags = hook->admin->eflags;

 		}

 	}

 }

 void ConCmdManager::RemoveConCmd(ConCmdInfo *info, const char *name, bool is_read_safe, bool untrack)

 {

 	/* Remove from the trie */

 	m_Cmds.remove(name);

 	/* Remove console-specific information

 	 * This should always be true as of right now

 	 */

 	if (info->pCmd)

 	{

 		if (info->sourceMod)

 		{

 			/* Unlink from SourceMM */

 			g_SMAPI->UnregisterConCommandBase(g_PLAPI, info->pCmd);

 			/* Delete the command's memory */

 			char *new_help = const_cast<char *>(info->pCmd->GetHelpText());

 			char *new_name = const_cast<char *>(info->pCmd->GetName());

 			delete [] new_help;

 			delete [] new_name;

 			delete info->pCmd;

 		}

 		else

 		{

 			if (is_read_safe)

 			{

 				/* Remove the external hook */

 				SH_REMOVE_HOOK(ConCommand, Dispatch, info->pCmd, SH_STATIC(CommandCallback), false);

 			}

 			if (untrack)

 			{

 				UntrackConCommandBase(info->pCmd, this);

 			}

 		}

 	}

 	/* Remove from list */

 	m_CmdList.remove(info);

 	delete info;

 }

 bool ConCmdManager::LookForSourceModCommand(const char *cmd)

 {

 	ConCmdInfo *pInfo;

 	if (!m_Cmds.retrieve(cmd, &pInfo))

 		return false;

 	return pInfo->sourceMod && !pInfo->hooks.empty();

 }

 bool ConCmdManager::LookForCommandAdminFlags(const char *cmd, FlagBits *pFlags)

 {

 	ConCmdInfo *pInfo;

 	if (!m_Cmds.retrieve(cmd, &pInfo))

 		return false;

 	*pFlags = pInfo->eflags;

 	return true;

 }

 ConCmdInfo *ConCmdManager::AddOrFindCommand(const char *name, const char *description, int flags)

 {

 	ConCmdInfo *pInfo;

 	if (!m_Cmds.retrieve(name, &pInfo))

 	{

 		ConCmdList::iterator item = FindInList(name);

 		if (item != m_CmdList.end())

 			return *item;

 		pInfo = new ConCmdInfo();

 		/* Find the commandopan */

 		ConCommand *pCmd = FindCommand(name);

 		if (!pCmd)

 		{

 			/* Note that we have to duplicate because the source might not be 

 			 * a static string, and these expect static memory.

 			 */

 			if (!description)

 			{

 				description = "";

 			}

 			char *new_name = sm_strdup(name);

 			char *new_help = sm_strdup(description);

 			pCmd = new ConCommand(new_name, CommandCallback, new_help, flags);

 			pInfo->sourceMod = true;

 		}

 		else

 		{

 			TrackConCommandBase(pCmd, this);

 			SH_ADD_HOOK(ConCommand, Dispatch, pCmd, SH_STATIC(CommandCallback), false);

 		}

 		pInfo->pCmd = pCmd;

 		m_Cmds.insert(name, pInfo);

 		AddToCmdList(pInfo);

 	}

 	return pInfo;

 }

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

 {

 	if (command.ArgC() >= 3)

 	{

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

 		IPlugin *pPlugin = scripts->FindPluginByConsoleArg(text);

 		if (!pPlugin)

 		{

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

 			return;

 		}

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

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

 		PluginHookList *pList;

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

 		{

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

 			return;

 		}

 		if (pList->empty())

 		{

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

 			return;

 		}

 		const char *type = NULL;

 		const char *name;

 		const char *help;

 		g_RootMenu.ConsolePrint("[SM] Listing commands for: %s", plname);

 		g_RootMenu.ConsolePrint("  %-17.16s %-8.7s %s", "[Name]", "[Type]", "[Help]");

 		for (PluginHookList::iterator iter = pList->begin(); iter != pList->end(); iter++)

 		{

 			CmdHook *hook = *iter;

 			if (hook->type == CmdHook::Server)

 				type = "server";

 			else 

 				type = hook->info->eflags == 0 ? "console" : "admin";

 			name = hook->info->pCmd->GetName();

 			if (hook->helptext.length())

 				help = hook->helptext.chars();

 			else

 				help = hook->info->pCmd->GetHelpText();

 			g_RootMenu.ConsolePrint("  %-17.16s %-12.11s %s", name, type, help);		

 		}

 		return;

 	}

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

 }