/**

  * vim: set ts=4 sw=4 :

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

  * 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 "sm_srvcmds.h"

 #include <sourcemod_version.h>

 #include "sm_stringutil.h"

 #include "HandleSys.h"

 #include "CoreConfig.h"

 #include "ConVarManager.h"

 #include "ShareSys.h"

 RootConsoleMenu g_RootMenu;

 ConVar sourcemod_version("sourcemod_version", SM_VERSION_STRING, FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY, "SourceMod Version");

 RootConsoleMenu::RootConsoleMenu()

 {

 	m_pCommands = sm_trie_create();

 	m_CfgExecDone = false;

 }

 RootConsoleMenu::~RootConsoleMenu()

 {

 	sm_trie_destroy(m_pCommands);

 	List<ConsoleEntry *>::iterator iter;

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

 	{

 		delete (*iter);

 	}

 	m_Menu.clear();

 }

 void RootConsoleMenu::OnSourceModStartup(bool late)

 {

 #if SOURCE_ENGINE >= SE_ORANGEBOX

 	g_pCVar = icvar;

 #endif

 	CONVAR_REGISTER(this);

 	AddRootConsoleCommand("version", "Display version information", this);

 	AddRootConsoleCommand("credits", "Display credits listing", this);

 }

 void RootConsoleMenu::OnSourceModAllInitialized()

 {

 	g_ShareSys.AddInterface(NULL, this);

 }

 void RootConsoleMenu::OnSourceModShutdown()

 {

 	RemoveRootConsoleCommand("credits", this);

 	RemoveRootConsoleCommand("version", this);

 }

 bool RootConsoleMenu::RegisterConCommandBase(ConCommandBase *pCommand)

 {

 	META_REGCVAR(pCommand);

 	/* Override values of convars created by SourceMod convar manager if specified on command line */

 	const char *cmdLineValue = icvar->GetCommandLineValue(pCommand->GetName());

 	if (cmdLineValue && !pCommand->IsCommand())

 	{

 		static_cast<ConVar *>(pCommand)->SetValue(cmdLineValue);

 	}

 	return true;

 }

 void RootConsoleMenu::ConsolePrint(const char *fmt, ...)

 {

 	char buffer[512];

 	va_list ap;

 	va_start(ap, fmt);

 	size_t len = vsnprintf(buffer, sizeof(buffer), fmt, ap);

 	va_end(ap);

 	if (len >= sizeof(buffer) - 1)

 	{

 		buffer[510] = '\n';

 		buffer[511] = '\0';

 	} else {

 		buffer[len++] = '\n';

 		buffer[len] = '\0';

 	}

 	META_CONPRINT(buffer);

 }

 bool RootConsoleMenu::AddRootConsoleCommand(const char *cmd, const char *text, IRootConsoleCommand *pHandler)

 {

 	return _AddRootConsoleCommand(cmd, text, pHandler, false);

 }

 bool RootConsoleMenu::AddRootConsoleCommand2(const char *cmd, const char *text, IRootConsoleCommand *pHandler)

 {

 	return _AddRootConsoleCommand(cmd, text, pHandler, true);

 }

 bool RootConsoleMenu::_AddRootConsoleCommand(const char *cmd,

 											 const char *text,

 											 IRootConsoleCommand *pHandler,

 											 bool version2)

 {

 	if (sm_trie_retrieve(m_pCommands, cmd, NULL))

 	{

 		return false;

 	}

 	/* Sort this into the menu */

 	List<ConsoleEntry *>::iterator iter = m_Menu.begin();

 	ConsoleEntry *pEntry;

 	bool inserted = false;

 	while (iter != m_Menu.end())

 	{

 		pEntry = (*iter);

 		if (strcmp(cmd, pEntry->command.c_str()) < 0)

 		{

 			ConsoleEntry *pNew = new ConsoleEntry;

 			pNew->command.assign(cmd);

 			pNew->description.assign(text);

 			pNew->version2 = version2;

 			pNew->cmd = pHandler;

 			sm_trie_insert(m_pCommands, cmd, pNew);

 			m_Menu.insert(iter, pNew);

 			inserted = true;

 			break;

 		}

 		iter++;

 	}

 	if (!inserted)

 	{

 		ConsoleEntry *pNew = new ConsoleEntry;

 		pNew->command.assign(cmd);

 		pNew->description.assign(text);

 		pNew->version2 = version2;

 		pNew->cmd = pHandler;

 		sm_trie_insert(m_pCommands, cmd, pNew);

 		m_Menu.push_back(pNew);

 	}

 	return true;

 }

 bool RootConsoleMenu::RemoveRootConsoleCommand(const char *cmd, IRootConsoleCommand *pHandler)

 {

 	sm_trie_delete(m_pCommands, cmd);

 	List<ConsoleEntry *>::iterator iter;

 	ConsoleEntry *pEntry;

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

 	{

 		pEntry = (*iter);

 		if (pEntry->command.compare(cmd) == 0)

 		{

 			delete pEntry;

 			m_Menu.erase(iter);

 			break;

 		}

 	}

 	return true;

 }

 void RootConsoleMenu::DrawGenericOption(const char *cmd, const char *text)

 {

 	char buffer[255];

 	size_t len, cmdlen = strlen(cmd);

 	len = UTIL_Format(buffer, sizeof(buffer), "    %s", cmd);

 	if (cmdlen < 16)

 	{

 		size_t num = 16 - cmdlen;

 		for (size_t i = 0; i < num; i++)

 		{

 			buffer[len++] = ' ';

 		}

 		len += snprintf(&buffer[len], sizeof(buffer) - len, " - %s", text);

 		ConsolePrint("%s", buffer);

 	}

 }

 const char *RootConsoleMenu::GetInterfaceName()

 {

 	return SMINTERFACE_ROOTCONSOLE_NAME;

 }

 unsigned int RootConsoleMenu::GetInterfaceVersion()

 {

 	return SMINTERFACE_ROOTCONSOLE_VERSION;

 }

 #if SOURCE_ENGINE==SE_EPISODEONE || SOURCE_ENGINE==SE_DARKMESSIAH

 class CCommandArgs : public ICommandArgs

 {

 public:

 	CCommandArgs(const CCommand& _cmd)

 	{

 	}

 	const char *Arg(int n) const

 	{

 		return engine->Cmd_Argv(n);

 	}

 	int ArgC() const

 	{

 		return engine->Cmd_Argc();

 	}

 	const char *ArgS() const

 	{

 		return engine->Cmd_Args();

 	}

 };

 #else

 class CCommandArgs : public ICommandArgs

 {

 	const CCommand *cmd;

 public:

 	CCommandArgs(const CCommand& _cmd) : cmd(&_cmd)

 	{

 	}

 	const char *Arg(int n) const

 	{

 		return cmd->Arg(n);

 	}

 	int ArgC() const

 	{

 		return cmd->ArgC();

 	}

 	const char *ArgS() const

 	{

 		return cmd->ArgS();

 	}

 };

 #endif

 void RootConsoleMenu::GotRootCmd(const CCommand &cmd)

 {

 	unsigned int argnum = cmd.ArgC();

 	if (argnum >= 2)

 	{

 		const char *cmdname = cmd.Arg(1);

 		if (strcmp(cmdname, "internal") == 0)

 		{

 			if (argnum >= 3)

 			{

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

 				if (strcmp(arg, "1") == 0)

 				{

 					SM_ConfigsExecuted_Global();

 				}

 				else if (strcmp(arg, "2") == 0)

 				{

 					if (argnum >= 4)

 					{

 						SM_ConfigsExecuted_Plugin(atoi(cmd.Arg(3)));

 					}

 				}

 			}

 			return;

 		}

 		CCommandArgs ocmd(cmd);

 		ConsoleEntry *entry;

 		if (sm_trie_retrieve(m_pCommands, cmdname, (void **)&entry))

 		{

 			if (entry->version2)

 			{

 				entry->cmd->OnRootConsoleCommand2(cmdname, &ocmd);

 			}

 			else

 			{

 				entry->cmd->OnRootConsoleCommand(cmdname, cmd);

 			}

 			return;

 		}

 	}

 	ConsolePrint("SourceMod Menu:");

 	ConsolePrint("Usage: sm <command> [arguments]");

 	List<ConsoleEntry *>::iterator iter;

 	ConsoleEntry *pEntry;

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

 	{

 		pEntry = (*iter);

 		DrawGenericOption(pEntry->command.c_str(), pEntry->description.c_str());

 	}

 }

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

 {

 	if (strcmp(cmdname, "credits") == 0)

 	{

 		ConsolePrint(" SourceMod was developed by AlliedModders, LLC.");

 		ConsolePrint(" Development would not have been possible without the following people:");

 		ConsolePrint("  David \"BAILOPAN\" Anderson");

 		ConsolePrint("  Matt \"pRED\" Woodrow");

 		ConsolePrint("  Scott \"DS\" Ehlert");

 		ConsolePrint("  Fyren");

 		ConsolePrint("  Nicholas \"psychonic\" Hastings");

 		ConsolePrint("  Asher \"asherkin\" Baker");

 		ConsolePrint("  Borja \"faluco\" Ferrer");

 		ConsolePrint("  Pavol \"PM OnoTo\" Marko");

 		ConsolePrint(" Special thanks to Liam, ferret, and Mani");

 		ConsolePrint(" Special thanks to Viper and SteamFriends");

 		ConsolePrint(" http://www.sourcemod.net/");

 	}

 	else if (strcmp(cmdname, "version") == 0)

 	{

 		ConsolePrint(" SourceMod Version Information:");

 		ConsolePrint("    SourceMod Version: %s", SM_VERSION_STRING);

 		ConsolePrint("    SourcePawn Engine: %s (build %s)", g_pSourcePawn2->GetEngineName(), g_pSourcePawn2->GetVersionString());

 		ConsolePrint("    SourcePawn API: v1 = %d, v2 = %d", g_pSourcePawn->GetEngineAPIVersion(), g_pSourcePawn2->GetAPIVersion());

 		ConsolePrint("    Compiled on: %s %s", __DATE__, __TIME__);

 		ConsolePrint("    Build ID: %s", SM_BUILD_UNIQUEID);

 		ConsolePrint("    http://www.sourcemod.net/");

 	}

 }

 CON_COMMAND(sm, "SourceMod Menu")

 {

 #if SOURCE_ENGINE <= SE_DARKMESSIAH

 	CCommand args;

 #endif

 	g_RootMenu.GotRootCmd(args);

 }

 FILE *g_pHndlLog = NULL;

 void write_handles_to_log(const char *fmt, ...)

 {

 	va_list ap;

 	va_start(ap, fmt);

 	vfprintf(g_pHndlLog, fmt, ap);

 	fprintf(g_pHndlLog, "\n");

 	va_end(ap);

 }

 void write_handles_to_game(const char *fmt, ...)

 {

 	size_t len;

 	va_list ap;

 	char buffer[1024];

 	va_start(ap, fmt);

 	len = UTIL_FormatArgs(buffer, sizeof(buffer)-2, fmt, ap);

 	va_end(ap);

 	buffer[len] = '\n';

 	buffer[len+1] = '\0';

 	engine->LogPrint(buffer);

 }

 CON_COMMAND(sm_dump_handles, "Dumps Handle usage to a file for finding Handle leaks")

 {

 #if SOURCE_ENGINE <= SE_DARKMESSIAH

 	CCommand args;

 #endif

 	if (args.ArgC() < 2)

 	{

 		g_RootMenu.ConsolePrint("Usage: sm_dump_handles <file> or <log> for game logs");

 		return;

 	}

 	if (strcmp(args.Arg(1), "log") != 0)

 	{

 		const char *arg = args.Arg(1);

 		FILE *fp = fopen(arg, "wt");

 		if (!fp)

 		{

 			g_RootMenu.ConsolePrint("Could not find file \"%s\"", arg);

 			return;

 		}

 		g_pHndlLog = fp;

 		g_HandleSys.Dump(write_handles_to_log);

 		g_pHndlLog = NULL;

 		fclose(fp);

 	}

 	else

 	{

 		g_HandleSys.Dump(write_handles_to_game);

 	}

 }