/**

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

#include <IPluginSys.h>

#include <IPlayerHelpers.h>

#include <sh_string.h>

#include <sh_list.h>

#include "CellArray.h"

#include "AutoHandleRooter.h"

using namespace SourceHook;

using namespace SourceMod;

class PlayerLogicHelpers : 

	public SMGlobalClass,

	public IPluginsListener,

	public ICommandTargetProcessor

{

	struct SimpleMultiTargetFilter

	{

		IPlugin *plugin;

		SourceHook::String pattern;

		IPluginFunction *fun;

		SourceHook::String phrase;

		bool phraseIsML;

		SimpleMultiTargetFilter(IPlugin *plugin, const char *pattern, IPluginFunction *fun,

		                        const char *phrase, bool phraseIsML)

		  : plugin(plugin), pattern(pattern), fun(fun), phrase(phrase), phraseIsML(phraseIsML)

		{

		}

	};

	List<SimpleMultiTargetFilter *> simpleMultis;

	bool filterEnabled;

public:

	void AddMultiTargetFilter(IPlugin *plugin, const char *pattern, IPluginFunction *fun,

	                          const char *phrase, bool phraseIsML)

	{

		SimpleMultiTargetFilter *smtf = new SimpleMultiTargetFilter(plugin, pattern, fun, phrase,

		                                                            phraseIsML);

		simpleMultis.push_back(smtf);

		if (!filterEnabled) {

			playerhelpers->RegisterCommandTargetProcessor(this);

			filterEnabled = true;

		}

	}

	void RemoveMultiTargetFilter(const char *pattern, IPluginFunction *fun)

	{

		List<SimpleMultiTargetFilter *>::iterator iter = simpleMultis.begin();

		while (iter != simpleMultis.end()) {

			if ((*iter)->fun == fun && strcmp((*iter)->pattern.c_str(), pattern) == 0) {

				delete (*iter);

				iter = simpleMultis.erase(iter);

				break;

			}

			iter++;

		}

	}

	PlayerLogicHelpers()

	 : filterEnabled(false)

	{

	}

public: //ICommandTargetProcessor

	bool ProcessCommandTarget(cmd_target_info_t *info)

	{

		List<SimpleMultiTargetFilter *>::iterator iter;

		for (iter = simpleMultis.begin(); iter != simpleMultis.end(); iter++) {

			SimpleMultiTargetFilter *smtf = (*iter);

			if (strcmp(smtf->pattern.c_str(), info->pattern) == 0) {

				CellArray *array = new CellArray(1);

				HandleSecurity sec(g_pCoreIdent, g_pCoreIdent);

				Handle_t hndl = handlesys->CreateHandleEx(htCellArray, array, &sec, NULL, NULL);

				AutoHandleCloner ahc(hndl, sec);

				if (ahc.getClone() == BAD_HANDLE) {

					smcore.LogError("[SM] Could not allocate a handle (%s, %d)", __FILE__, __LINE__);

					delete array;

					return false;

				}

				smtf->fun->PushString(info->pattern);

				smtf->fun->PushCell(ahc.getClone());

				cell_t result = 0;

				if (smtf->fun->Execute(&result) != SP_ERROR_NONE || !result)

					return false;

				IGamePlayer *pAdmin = info->admin

				                      ? playerhelpers->GetGamePlayer(info->admin)

				                      : NULL;

				info->num_targets = 0;

				for (size_t i = 0; i < array->size(); i++) {

					cell_t client = *array->at(i);

					IGamePlayer *pClient = playerhelpers->GetGamePlayer(client);

					if (pClient == NULL || !pClient->IsConnected())

						continue;

					if (playerhelpers->FilterCommandTarget(pAdmin, pClient, info->flags) ==

					    COMMAND_TARGET_VALID)

					{

						info->targets[info->num_targets++] = client;

						if (info->num_targets >= unsigned(info->max_targets))

							break;

					}

				}

				info->reason = info->num_targets > 0

				               ? COMMAND_TARGET_VALID

				               : COMMAND_TARGET_EMPTY_FILTER;

				if (info->num_targets) {

					smcore.strncopy(info->target_name, smtf->phrase.c_str(), info->target_name_maxlength);

					info->target_name_style = smtf->phraseIsML

					                          ? COMMAND_TARGETNAME_ML

					                          : COMMAND_TARGETNAME_RAW;

				}

				return true;

			}

		}

		return false;

	}

public: //SMGlobalClass

	void OnSourceModAllInitialized()

	{

		pluginsys->AddPluginsListener(this);

	}

	void OnSourceModShutdown()

	{

		pluginsys->RemovePluginsListener(this);

		if (filterEnabled) {

			playerhelpers->UnregisterCommandTargetProcessor(this);

			filterEnabled = false;

		}

	}

public: //IPluginsListener

	void OnPluginDestroyed(IPlugin *plugin)

	{

		List<SimpleMultiTargetFilter *>::iterator iter = simpleMultis.begin();

		while (iter != simpleMultis.end()) {

			if ((*iter)->plugin != plugin) {

				iter++;

			} else {

				delete (*iter);

				iter = simpleMultis.erase(iter);

			}

		}

	}

} s_PlayerLogicHelpers;

static cell_t

AddMultiTargetFilter(IPluginContext *ctx, const cell_t *params)

{

	IPluginFunction *fun = ctx->GetFunctionById(funcid_t(params[2]));

	if (fun == NULL)

		return ctx->ThrowNativeError("Invalid function id (%X)", params[2]);

	char *pattern;

	char *phrase;

	ctx->LocalToString(params[1], &pattern);

	ctx->LocalToString(params[3], &phrase);

	bool phraseIsML = !!params[4];

	IPlugin *plugin = pluginsys->FindPluginByContext(ctx->GetContext());

	s_PlayerLogicHelpers.AddMultiTargetFilter(plugin, pattern, fun, phrase, phraseIsML);

	return 1;

}

static cell_t

RemoveMultiTargetFilter(IPluginContext *ctx, const cell_t *params)

{

	IPluginFunction *fun = ctx->GetFunctionById(funcid_t(params[2]));

	if (fun == NULL)

		return ctx->ThrowNativeError("Invalid function id (%X)", params[2]);

	char *pattern;

	ctx->LocalToString(params[1], &pattern);

	s_PlayerLogicHelpers.RemoveMultiTargetFilter(pattern, fun);

	return 1;

}

REGISTER_NATIVES(playernatives)

{

	{"AddMultiTargetFilter",	AddMultiTargetFilter},

	{"RemoveMultiTargetFilter",	RemoveMultiTargetFilter},

	{NULL,						NULL}

};