/**

* vim: set ts=4 :

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

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

#include "sm_globals.h"

#include "sm_stringutil.h"

#include "CellArray.h"

#include "HandleSys.h"

HandleType_t htCellStack;

class CellStackHelpers : 

	public SMGlobalClass,

	public IHandleTypeDispatch

{

public: //SMGlobalClass

	void OnSourceModAllInitialized()

	{

		htCellStack = g_HandleSys.CreateType("CellStack", this, 0, NULL, NULL, g_pCoreIdent, NULL);

	}

	void OnSourceModShutdown()

	{

		g_HandleSys.RemoveType(htCellStack, g_pCoreIdent);

	}

public: //IHandleTypeDispatch

	void OnHandleDestroy(HandleType_t type, void *object)

	{

		CellArray *array = (CellArray *)object;

		delete array;

	}

	bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)

	{

		CellArray *pArray = (CellArray *)object;

		*pSize = sizeof(CellArray) + pArray->mem_usage();

		return true;

	}

} s_CellStackHelpers;

static cell_t CreateStack(IPluginContext *pContext, const cell_t *params)

{

	if (params[1] < 1)

	{

		return pContext->ThrowNativeError("Invalid block size (must be > 0)");

	}

	CellArray *array = new CellArray(params[1]);

	Handle_t hndl = g_HandleSys.CreateHandle(htCellStack, array, pContext->GetIdentity(), g_pCoreIdent, NULL);

	if (!hndl)

	{

		delete array;

	}

	return hndl;

}

static cell_t PushStackCell(IPluginContext *pContext, const cell_t *params)

{

	CellArray *array;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	cell_t *blk = array->push();

	if (!blk)

	{

		return pContext->ThrowNativeError("Failed to grow stack");

	}

	*blk = params[2];

	return 1;

}

static cell_t PushStackString(IPluginContext *pContext, const cell_t *params)

{

	CellArray *array;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	cell_t *blk = array->push();

	if (!blk)

	{

		return pContext->ThrowNativeError("Failed to grow stack");

	}

	char *str;

	pContext->LocalToString(params[2], &str);

	strncopy((char *)blk, str, array->blocksize() * sizeof(cell_t));

	return 1;

}

static cell_t PushStackArray(IPluginContext *pContext, const cell_t *params)

{

	CellArray *array;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	cell_t *blk = array->push();

	if (!blk)

	{

		return pContext->ThrowNativeError("Failed to grow array");

	}

	cell_t *addr;

	pContext->LocalToPhysAddr(params[2], &addr);

	size_t indexes = array->blocksize();

	if (params[3] != -1 && (size_t)params[3] <= array->blocksize())

	{

		indexes = params[3];

	}

	memcpy(blk, addr, sizeof(cell_t) * indexes);

	return 1;

}

static cell_t PopStackCell(IPluginContext *pContext, const cell_t *params)

{

	size_t idx;

	HandleError err;

	CellArray *array;

	cell_t *blk, *buffer;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	if (array->size() == 0)

	{

		return 0;

	}

	pContext->LocalToPhysAddr(params[2], &buffer);

	blk = array->at(array->size() - 1);

	idx = (size_t)params[3];

	if (params[4] == 0)

	{

		if (idx >= array->blocksize())

		{

			return pContext->ThrowNativeError("Invalid block %d (blocksize: %d)", idx, array->blocksize());

		}

		*buffer = blk[idx];

	}

	else

	{

		if (idx >= array->blocksize() * 4)

		{

			return pContext->ThrowNativeError("Invalid byte %d (blocksize: %d bytes)", idx, array->blocksize() * 4);

		}

		*buffer = (cell_t)*((char *)blk + idx);

	}

	array->remove(array->size() - 1);

	return 1;

}

static cell_t PopStackString(IPluginContext *pContext, const cell_t *params)

{

	HandleError err;

	CellArray *array;

	size_t idx, numWritten;

	cell_t *blk, *pWritten;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	if (array->size() == 0)

	{

		return 0;

	}

	idx = array->size() - 1;

	blk = array->at(idx);

	pContext->StringToLocalUTF8(params[2], params[3], (char *)blk, &numWritten);

	pContext->LocalToPhysAddr(params[4], &pWritten);

	*pWritten = (cell_t)numWritten;

	array->remove(idx);

	return 1;

}

static cell_t PopStackArray(IPluginContext *pContext, const cell_t *params)

{

	size_t idx;

	cell_t *blk;

	cell_t *addr;

	size_t indexes;

	HandleError err;

	CellArray *array;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	if (array->size() == 0)

	{

		return 0;

	}

	idx = array->size() - 1;

	blk = array->at(idx);

	indexes = array->blocksize();

	if (params[3] != -1 && (size_t)params[3] <= array->blocksize())

	{

		indexes = params[3];

	}

	pContext->LocalToPhysAddr(params[2], &addr);

	memcpy(addr, blk, sizeof(cell_t) * indexes);

	array->remove(idx);

	return indexes;

}

static cell_t IsStackEmpty(IPluginContext *pContext, const cell_t *params)

{

	HandleError err;

	CellArray *array;

	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);

	if ((err = g_HandleSys.ReadHandle(params[1], htCellStack, &sec, (void **)&array)) 

		!= HandleError_None)

	{

		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);

	}

	if (array->size() == 0)

	{

		return 1;

	}

	return 0;

}

REGISTER_NATIVES(cellStackNatives)

{

	{"CreateStack",					CreateStack},

	{"IsStackEmpty",				IsStackEmpty},

	{"PopStackArray",				PopStackArray},

	{"PopStackCell",				PopStackCell},

	{"PopStackString",				PopStackString},

	{"PushStackArray",				PushStackArray},

	{"PushStackCell",				PushStackCell},

	{"PushStackString",				PushStackString},

	{NULL,							NULL},

};