/**

 * vim: set ts=4 :

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

 * SourceMod SDKTools Extension

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

#include "extension.h"

ValveCall::ValveCall()

{

	call = NULL;

	vparams = NULL;

	retinfo = NULL;

	thisinfo = NULL;

	retbuf = NULL;

}

ValveCall::~ValveCall()

{

	while (!stk.empty())

	{

		unsigned char *ptr = stk.front();

		delete [] ptr;

		stk.pop();

	}

	if (call)

	{

		call->Destroy();

	}

	delete [] retbuf;

	delete [] vparams;

}

unsigned char *ValveCall::stk_get()

{

	unsigned char *ptr;

	if (stk.empty())

	{

		ptr = new unsigned char[stackSize];

	} else {

		ptr = stk.front();

		stk.pop();

	}

	return ptr;

}

void ValveCall::stk_put(unsigned char *ptr)

{

	stk.push(ptr);

}

ValveCall *CreateValveCall(void *addr,

						   ValveCallType vcalltype,

						   const ValvePassInfo *retInfo,

						   const ValvePassInfo *params,

						   unsigned int numParams)

{

	if (numParams > 32)

	{

		return NULL;

	}

	ValveCall *vc = new ValveCall;

	vc->type = vcalltype;

	size_t size = 0;

	vc->stackSize = 0;

	/* Get return information - encode only */

	PassInfo retBuf;

	size_t retBufSize = 0;

	bool retbuf_needs_extra;

	if (retInfo)

	{

		if ((size = ValveParamToBinParam(retInfo->vtype, retInfo->type, retInfo->flags, &retBuf, retbuf_needs_extra)) == 0)

		{

			delete vc;

			return NULL;

		}

		retBufSize = retBuf.size;

	}

	/* Get parameter info */

	PassInfo paramBuf[32];

	size_t sizes[32];

	size_t normSize = 0;

	size_t extraSize = 0;

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

	{

		bool needs_extra;

		if ((size = ValveParamToBinParam(params[i].vtype, 

			params[i].type,

			params[i].flags,

			&paramBuf[i],

			needs_extra)) == 0)

		{

			delete vc;

			return NULL;

		}

		if (needs_extra)

		{

			sizes[i] = size;

		} else {

			sizes[i] = 0;

		}

		normSize += paramBuf[i].size;

		extraSize += sizes[i];

	}

	/* Get thisinfo if needed */

	ValvePassInfo thisbuf;

	ValvePassInfo *thisinfo = NULL;

	CallConvention cv = CallConv_Cdecl;

	if (vcalltype != ValveCall_Static)

	{

		thisinfo = &thisbuf;

		thisinfo->type = PassType_Basic;

		switch (vcalltype)

		{

		case ValveCall_Entity:

			thisinfo->vtype = Valve_CBaseEntity;

			thisinfo->flags = PASSFLAG_BYVAL;

			thisinfo->decflags |= VDECODE_FLAG_ALLOWWORLD;

			break;

		case ValveCall_Player:

			thisinfo->vtype = Valve_CBasePlayer;

			thisinfo->flags = PASSFLAG_BYVAL;

			thisinfo->decflags = 0;

			break;

		case ValveCall_GameRules:

			thisinfo->vtype = Valve_POD;

			thisinfo->flags = PASSFLAG_ASPOINTER;

			thisinfo->decflags = 0;

		}

		thisinfo->encflags = 0;

		thisinfo->offset = 0;

		normSize += sizeof(void *);

		cv = CallConv_ThisCall;

	}

	/* Now we can try creating the call */

	if ((vc->call = g_pBinTools->CreateCall(addr,

		cv,

		(retInfo ? &retBuf : NULL),

		paramBuf,

		numParams))

		== NULL)

	{

		if (!vc->call)

		{

			delete vc;

			return NULL;

		}

	}

	/* Allocate extra space for thisptr AND ret buffer, even if we don't use it */

	vc->vparams = new ValvePassInfo[numParams + 2];

	/* We've got the call and everything is encoded.

	 * It's time to save the valve specific information and helper variables.

	 */

	if (retInfo)

	{

		/* Allocate and copy */

		vc->retinfo = &(vc->vparams[numParams]);

		*vc->retinfo = *retInfo;

		vc->retinfo->offset = 0;

		vc->retinfo->obj_offset = retbuf_needs_extra ? sizeof(void *) : 0;

		/* Allocate stack space */

		vc->retbuf = new unsigned char[retBufSize];

	} else {

		vc->retinfo = NULL;

		vc->retbuf = NULL;

	}

	if (thisinfo)

	{

		/* Allocate and copy */

		vc->thisinfo = &(vc->vparams[numParams + 1]);

		*vc->thisinfo = *thisinfo;

		vc->thisinfo->offset = 0;

		vc->thisinfo->obj_offset = 0;

	} else {

		vc->thisinfo = NULL;

	}

	/* Now, save info about each parameter. */

	size_t last_extra_offset = 0;

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

	{

		/* Copy */

		vc->vparams[i] = params[i];

		vc->vparams[i].offset = vc->call->GetParamInfo(i)->offset;

		vc->vparams[i].obj_offset = last_extra_offset;

		last_extra_offset += sizes[i];

	}

	vc->stackSize = normSize + extraSize;

	vc->stackEnd = normSize;

	return vc;

}

ValveCall *CreateValveVCall(unsigned int vtableIdx,

							ValveCallType vcalltype,

							const ValvePassInfo *retInfo,

							const ValvePassInfo *params,

							unsigned int numParams)

{

	if (numParams > 32)

	{

		return NULL;

	}

	ValveCall *vc = new ValveCall;

	vc->type = vcalltype;

	size_t size = 0;

	vc->stackSize = 0;

	/* Get return information - encode only */

	PassInfo retBuf;

	size_t retBufSize = 0;

	bool retbuf_needs_extra;

	if (retInfo)

	{

		if ((size = ValveParamToBinParam(retInfo->vtype, retInfo->type, retInfo->flags, &retBuf, retbuf_needs_extra)) == 0)

		{

			delete vc;

			return NULL;

		}

		retBufSize = retBuf.size;

	}

	/* Get parameter info */

	PassInfo paramBuf[32];

	size_t sizes[32];

	size_t normSize = 0;

	size_t extraSize = 0;

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

	{

		bool needs_extra;

		if ((size = ValveParamToBinParam(params[i].vtype, 

										params[i].type,

										params[i].flags,

										&paramBuf[i],

										needs_extra)) == 0)

		{

			delete vc;

			return NULL;

		}

		if (needs_extra)

		{

			sizes[i] = size;

		} else {

			sizes[i] = 0;

		}

		normSize += paramBuf[i].size;

		extraSize += sizes[i];

	}

	/* Now we can try creating the call */

	if ((vc->call = g_pBinTools->CreateVCall(vtableIdx, 

		0, 

		0, 

		(retInfo ? &retBuf : NULL),

		paramBuf,

		numParams))

		== NULL)

	{

		if (!vc->call)

		{

			delete vc;

			return NULL;

		}

	}

	/* Allocate extra space for thisptr AND ret buffer, even if we don't use it */

	vc->vparams = new ValvePassInfo[numParams + 2];

	/* We've got the call and everything is encoded.

	 * It's time to save the valve specific information and helper variables.

	 */

	if (retInfo)

	{

		/* Allocate and copy */

		vc->retinfo = &(vc->vparams[numParams]);

		*vc->retinfo = *retInfo;

		vc->retinfo->offset = 0;

		vc->retinfo->obj_offset = retbuf_needs_extra ? sizeof(void *) : 0;

		/* Allocate stack space */

		vc->retbuf = new unsigned char[retBufSize];

	} else {

		vc->retinfo = NULL;

		vc->retbuf = NULL;

	}

	/* Save the this info for the dynamic decoder */

	vc->thisinfo = &(vc->vparams[numParams + 1]);

	vc->thisinfo->type = PassType_Basic;

	switch (vcalltype)

	{

	case ValveCall_Entity:

		vc->thisinfo->vtype = Valve_CBaseEntity;

		vc->thisinfo->flags = PASSFLAG_BYVAL;

		vc->thisinfo->decflags = VDECODE_FLAG_ALLOWWORLD;

		break;

	case ValveCall_Player:

		vc->thisinfo->vtype = Valve_CBasePlayer;

		vc->thisinfo->flags = PASSFLAG_BYVAL;

		vc->thisinfo->decflags = 0;

		break;

	case ValveCall_GameRules:

		vc->thisinfo->vtype = Valve_POD;

		vc->thisinfo->flags = PASSFLAG_ASPOINTER;

		vc->thisinfo->decflags = 0;

		break;

	}

	vc->thisinfo->encflags = 0;

	vc->thisinfo->offset = 0;

	vc->thisinfo->obj_offset = 0;

	normSize += sizeof(void *);

	/* Now, save info about each parameter. */

	size_t last_extra_offset = 0;

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

	{

		/* Copy */

		vc->vparams[i] = params[i];

		vc->vparams[i].offset = vc->call->GetParamInfo(i)->offset;

		vc->vparams[i].obj_offset = last_extra_offset;

		last_extra_offset += sizes[i];

	}

	vc->stackSize = normSize + extraSize;

	vc->stackEnd = normSize;

	return vc;

}