/**

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

#include <stdarg.h>

#include <string.h>

#include "ForwardSys.h"

#include "PluginSys.h"

#include "ShareSys.h"

CForwardManager g_Forwards;

/**

 * Genesis turns to its source, reduction occurs stepwise although the essence is all one.

 * End of line.  FTL system check.

 *

 * :TODO: WHAT NEEDS TO BE TESTED IN THIS BEAST

 * VARARG FUNCTIONS:

 * - Pushing no varargs

 */

// :TODO: IMPORTANT!!! The result pointer arg in the execute function maybe invalid if the forward fails

// so later evaluation of this result may cause problems on higher levels of abstraction. DOCUMENT OR FIX ALL FORWARDS!

CForwardManager::~CForwardManager()

{

	CStack<CForward *>::iterator iter;

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

	{

		delete (*iter);

	}

	m_FreeForwards.popall();

}

void CForwardManager::OnSourceModAllInitialized()

{

	g_PluginSys.AddPluginsListener(this);

	g_ShareSys.AddInterface(NULL, this);

}

IForward *CForwardManager::CreateForward(const char *name, ExecType et, unsigned int num_params, const ParamType *types, ...)

{

	CForward *fwd;

	va_list ap;

	va_start(ap, types);

	fwd = CForward::CreateForward(name, et, num_params, types, ap);

	va_end(ap);

	if (fwd)

	{

		g_PluginSys.AddFunctionsToForward(name, fwd);

		m_managed.push_back(fwd);

	}

	return fwd;

}

IChangeableForward *CForwardManager::CreateForwardEx(const char *name, ExecType et, int num_params, const ParamType *types, ...)

{

	CForward *fwd;

	va_list ap;

	va_start(ap, types);

	fwd = CForward::CreateForward(name, et, num_params, types, ap);

	va_end(ap);

	if (fwd)

	{

		m_unmanaged.push_back(fwd);

	}

	return fwd;

}

void CForwardManager::OnPluginLoaded(IPlugin *plugin)

{

	/* Attach any globally managed forwards */

	List<CForward *>::iterator iter;

	CForward *fwd;

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

	{

		fwd = (*iter);

		IPluginFunction *pFunc = plugin->GetBaseContext()->GetFunctionByName(fwd->GetForwardName());

		if (pFunc)

		{

			fwd->AddFunction(pFunc);

		}

	}

}

void CForwardManager::OnPluginUnloaded(IPlugin *plugin)

{

	List<CForward *>::iterator iter;

	CForward *fwd;

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

	{

		fwd = (*iter);

		fwd->RemoveFunctionsOfPlugin(plugin);

	}

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

	{

		fwd = (*iter);

		fwd->RemoveFunctionsOfPlugin(plugin);

	}

}

IForward *CForwardManager::FindForward(const char *name, IChangeableForward **ifchng)

{

	List<CForward *>::iterator iter;

	CForward *fwd;

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

	{

		fwd = (*iter);

		if (strcmp(fwd->GetForwardName(), name) == 0)

		{

			if (ifchng)

			{

				*ifchng = NULL;

			}

			return fwd;

		}

	}

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

	{

		fwd = (*iter);

		if (strcmp(fwd->GetForwardName(), name) == 0)

		{

			if (ifchng)

			{

				*ifchng = fwd;

			}

			return fwd;

		}

	}

	if (ifchng)

	{

		*ifchng = NULL;

	}

	return NULL;

}

void CForwardManager::ReleaseForward(IForward *forward)

{

	ForwardFree(static_cast<CForward *>(forward));

}

void CForwardManager::ForwardFree(CForward *fwd)

{

	m_FreeForwards.push(fwd);

	m_managed.remove(fwd);

}

CForward *CForwardManager::ForwardMake()

{

	CForward *fwd;

	if (m_FreeForwards.empty())

	{

		fwd = new CForward;

	} else {

		fwd = m_FreeForwards.front();

		m_FreeForwards.pop();

	}

	return fwd;

}

void CForwardManager::OnPluginPauseChange(IPlugin *plugin, bool paused)

{

	/* No longer used */

}

/*************************************

 * ACTUAL FORWARD API IMPLEMENTATION *

 *************************************/

CForward *CForward::CreateForward(const char *name, ExecType et, unsigned int num_params, const ParamType *types, va_list ap)

{

	ParamType _types[SP_MAX_EXEC_PARAMS];

	if (num_params > SP_MAX_EXEC_PARAMS)

	{

		return NULL;

	}

	if (types == NULL && num_params)

	{

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

		{

			_types[i] = (ParamType)va_arg(ap, int);

			if (_types[i] == Param_VarArgs && (i != num_params - 1))

			{

				return NULL;

			}

		}

		types = _types;

	} else {

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

		{

			_types[i] = types[i];

			if (types[i] == Param_VarArgs && (i != num_params - 1))

			{

				return NULL;

			}

		}

	}

	/* First parameter can never be varargs */

	if (num_params && _types[0] == Param_VarArgs)

	{

		return NULL;

	}

	CForward *pForward = g_Forwards.ForwardMake();

	pForward->m_curparam = 0;

	pForward->m_ExecType = et;

	snprintf(pForward->m_name, FORWARDS_NAME_MAX, "%s", name ? name : "");

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

	{

		pForward->m_types[i] = _types[i];

	}

	if (num_params && _types[num_params-1] == Param_VarArgs)

	{

		pForward->m_varargs = num_params--;

	} else {

		pForward->m_varargs = false;

	}

	pForward->m_numparams = num_params;

	pForward->m_errstate = SP_ERROR_NONE;

	pForward->m_functions.clear();

	return pForward;

}

int CForward::Execute(cell_t *result, IForwardFilter *filter)

{

	if (m_errstate)

	{

		int err = m_errstate;

		Cancel();

		return err;

	}

	if (filter)

	{

		filter->OnExecuteBegin();

	}

	FuncIter iter = m_functions.begin();

	IPluginFunction *func;

	cell_t cur_result = 0;

	cell_t high_result = 0;

	int err;

	unsigned int failed=0, success=0;

	unsigned int num_params = m_curparam;

	FwdParamInfo temp_info[SP_MAX_EXEC_PARAMS];

	FwdParamInfo *param;

	ParamType type;

	/* Save local, reset */

	memcpy(temp_info, m_params, sizeof(m_params));

	m_curparam = 0;

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

	{

		func = (*iter);

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

		{

			param = &temp_info[i];

			if (i >= m_numparams || m_types[i] == Param_Any)

			{

				type = param->pushedas;

			} else {

				type = m_types[i];

			}

			if ((i >= m_numparams) || (type & SP_PARAMFLAG_BYREF))

			{

				/* If we're byref or we're vararg, we always push everything by ref.

				 * Even if they're byval, we must push them byref.

				 */

				if (type == Param_String)

				{

					func->PushStringEx((char *)param->byref.orig_addr, param->byref.cells, param->byref.sz_flags, param->byref.flags);

				} else if (type == Param_Float || type == Param_Cell) {

					func->PushCellByRef(&param->val); 

				} else {

					func->PushArray(param->byref.orig_addr, param->byref.cells, param->byref.flags);

					assert(type == Param_Array || type == Param_FloatByRef || type == Param_CellByRef);

				}

			} else {

				/* If we're not byref or not vararg, our job is a bit easier. */

				assert(type == Param_Cell || type == Param_Float);

				func->PushCell(param->val);

			}

		}

		/* Call the function and deal with the return value. */

		if ((err=func->Execute(&cur_result)) != SP_ERROR_NONE)

		{

			bool handled = false;

			if (filter)

			{

				handled = filter->OnErrorReport(this, func, err);

			}

			if (!handled)

			{

				/* :TODO: invoke global error reporting here */

			}

			failed++;

		} else {

			success++;

			switch (m_ExecType)

			{

			case ET_Event:

				{

					if (cur_result > high_result)

					{

						high_result = cur_result;

					}

					break;

				}

			case ET_Hook:

				{

					if (cur_result > high_result)

					{

						high_result = cur_result;

						if ((ResultType)high_result == Pl_Stop)

						{

							goto done;

						}

					}

					break;

				}

			case ET_Custom:

				{

					if (filter)

					{

						if (filter->OnFunctionReturn(this, func, &cur_result) == Pl_Stop)

						{

							goto done;

						}

					}

					break;

				}

			default:

				{

					break;

				}

			}

		}

	}

done:

	if (success)

	{

		if (m_ExecType == ET_Event || m_ExecType == ET_Hook)

		{

			cur_result = high_result;

		} else if (m_ExecType == ET_Ignore) {

			cur_result = 0;

		}

		if (result)

		{

			*result = cur_result;

		}

	}

	if (filter)

	{

		filter->OnExecuteEnd(&cur_result, success, failed);

	}

	return SP_ERROR_NONE;

}

int CForward::PushCell(cell_t cell)

{

	if (m_curparam < m_numparams)

	{

		if (m_types[m_curparam] == Param_Any)

		{

			m_params[m_curparam].pushedas = Param_Cell;

		} else if (m_types[m_curparam] != Param_Cell) {

			return SetError(SP_ERROR_PARAM);

		}

	} else {

		if (!m_varargs || m_numparams > SP_MAX_EXEC_PARAMS)

		{

			return SetError(SP_ERROR_PARAMS_MAX);

		}

		m_params[m_curparam].pushedas = Param_Cell;

	}

	m_params[m_curparam++].val = cell;

	return SP_ERROR_NONE;

}

int CForward::PushFloat(float number)

{

	if (m_curparam < m_numparams)

	{

		if (m_types[m_curparam] == Param_Any)

		{

			m_params[m_curparam].pushedas = Param_Float;

		} else if (m_types[m_curparam] != Param_Float) {

			return SetError(SP_ERROR_PARAM);

		}

	} else {

		if (!m_varargs || m_numparams > SP_MAX_EXEC_PARAMS)

		{

			return SetError(SP_ERROR_PARAMS_MAX);

		}

		m_params[m_curparam].pushedas = Param_Float;

	}

	m_params[m_curparam++].val = *(cell_t *)&number;

	return SP_ERROR_NONE;

}

int CForward::PushCellByRef(cell_t *cell, int flags)

{

	if (m_curparam < m_numparams)

	{

		if (m_types[m_curparam] == Param_Any)

		{

			m_params[m_curparam].pushedas = Param_CellByRef;

		} else if (m_types[m_curparam] != Param_CellByRef) {

			return SetError(SP_ERROR_PARAM);

		}

	} else {

		if (!m_varargs || m_numparams > SP_MAX_EXEC_PARAMS)

		{

			return SetError(SP_ERROR_PARAMS_MAX);

		}

		m_params[m_curparam].pushedas = Param_CellByRef;

	}

	_Int_PushArray(cell, 1, flags);

	m_curparam++;

	return SP_ERROR_NONE;

}

int CForward::PushFloatByRef(float *num, int flags)

{

	if (m_curparam < m_numparams)

	{

		if (m_types[m_curparam] == Param_Any)

		{

			m_params[m_curparam].pushedas = Param_FloatByRef;

		} else if (m_types[m_curparam] != Param_FloatByRef) {

			return SetError(SP_ERROR_PARAM);

		}

	} else {

		if (!m_varargs || m_numparams > SP_MAX_EXEC_PARAMS)

		{

			return SetError(SP_ERROR_PARAMS_MAX);

		}

		m_params[m_curparam].pushedas = Param_FloatByRef;

	}

	_Int_PushArray((cell_t *)num, 1, flags);

	m_curparam++;

	return SP_ERROR_NONE;

}

void CForward::_Int_PushArray(cell_t *inarray, unsigned int cells, int flags)

{

	m_params[m_curparam].byref.cells = cells;

	m_params[m_curparam].byref.flags = flags;

	m_params[m_curparam].byref.orig_addr = inarray;

}

int CForward::PushArray(cell_t *inarray, unsigned int cells, int flags)

{

	/* We don't allow this here */

	if (!inarray)

	{

		return SetError(SP_ERROR_PARAM);

	}

	if (m_curparam < m_numparams)

	{

		if (m_types[m_curparam] == Param_Any)

		{

			m_params[m_curparam].pushedas = Param_Array;

		} else if (m_types[m_curparam] != Param_Array) {

			return SetError(SP_ERROR_PARAM);

		}

	} else {

		if (!m_varargs || m_curparam > SP_MAX_EXEC_PARAMS)

		{

			return SetError(SP_ERROR_PARAMS_MAX);

		}

		m_params[m_curparam].pushedas = Param_Array;

	}

	_Int_PushArray(inarray, cells, flags);

	m_curparam++;

	return SP_ERROR_NONE;

}

void CForward::_Int_PushString(cell_t *inarray, unsigned int cells, int sz_flags, int cp_flags)

{

	m_params[m_curparam].byref.cells = cells;	/* Notice this contains the char count not cell count */

	m_params[m_curparam].byref.flags = cp_flags;

	m_params[m_curparam].byref.orig_addr = inarray;

	m_params[m_curparam].byref.sz_flags = sz_flags;

}

int CForward::PushString(const char *string)

{

	if (m_curparam < m_numparams)

	{

		if (m_types[m_curparam] == Param_Any)

		{

			m_params[m_curparam].pushedas = Param_String;

		} else if (m_types[m_curparam] != Param_String) {

			return SetError(SP_ERROR_PARAM);

		}

	} else {

		if (!m_varargs || m_curparam > SP_MAX_EXEC_PARAMS)

		{

			return SetError(SP_ERROR_PARAMS_MAX);

		}

		m_params[m_curparam].pushedas = Param_String;

	}

	_Int_PushString((cell_t *)string, strlen(string)+1, SM_PARAM_STRING_COPY, 0);

	m_curparam++;

	return SP_ERROR_NONE;

}