/**

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

#include "sourcemm_api.h"

#include "sm_stringutil.h"

#include "HandleSys.h"

#include "HalfLife2.h"

#include <KeyValues.h>

#include "utlbuffer.h"

HandleType_t g_KeyValueType;

struct KeyValueStack 

{

	KeyValues *pBase;

	CStack<KeyValues *> pCurRoot;

};

class KeyValueNatives : 

	public SMGlobalClass,

	public IHandleTypeDispatch

{

public:

	void OnSourceModAllInitialized()

	{

		g_KeyValueType = g_HandleSys.CreateType("KeyValues", this, 0, NULL, NULL, g_pCoreIdent, NULL);

	}

	void OnSourceModShutdown()

	{

		g_HandleSys.RemoveType(g_KeyValueType, g_pCoreIdent);

		g_KeyValueType = 0;

	}

	void OnHandleDestroy(HandleType_t type, void *object)

	{

		KeyValueStack *pStk = reinterpret_cast<KeyValueStack *>(object);

		pStk->pBase->deleteThis();

		delete pStk;

	}

	int CalcKVSizeR(KeyValues *pv)

	{

		CUtlBuffer buf;

		int size;

		pv->RecursiveSaveToFile(buf, 0);

		size = buf.TellMaxPut();

		buf.Purge();

		return size;

	}

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

	{

		KeyValueStack *pStk = (KeyValueStack *)object;

		unsigned int size = sizeof(KeyValueStack) + (pStk->pCurRoot.size() * sizeof(KeyValues *));

		/* Check how much memory the actual thing takes up */		

		size += CalcKVSizeR(pStk->pBase);

		*pSize = size;

		return true;

	}

};

/* From MM:S - metamod_util.cpp */

inline bool pathchar_isalpha(char a)

{

	return (((a & 1<<7) == 0) && isalpha(a));

}

inline bool pathchar_sep(char a)

{

#if defined WIN32

	return (a == '/' || a == '\\');

#elif defined __linux__

	return (a == '/');

#endif

}

inline bool pathstr_isabsolute(const char *str)

{

#if defined WIN32

	return (pathchar_isalpha(str[0]) 

		&& str[1] == ':' 

		&& pathchar_sep(str[2]));

#elif defined __linux__

	return (str[0] == '/');

#endif

}

inline bool pathchar_cmp(char a, char b)

{

#if defined PLATFORM_WINDOWS

	if (pathchar_isalpha(a) && pathchar_isalpha(b))

	{

		return (tolower(a) == tolower(b));

	}

	/* Either path separator is acceptable */

	if (pathchar_sep(a))

	{

		return pathchar_sep(b);

	}

#endif

	return (a == b);

}

bool UTIL_Relatize(char buffer[],

				   size_t maxlength,

				   const char *relTo,

				   const char *relFrom)

{

	/* We don't allow relative paths in here, force

	* the user to resolve these himself!

	*/

	if (!pathstr_isabsolute(relTo)

		|| !pathstr_isabsolute(relFrom))

	{

		return false;

	}

#if defined PLATFORM_WINDOWS

	/* Relative paths across drives are not possible */

	if (!pathchar_cmp(relTo[0], relFrom[0]))

	{

		return false;

	}

	/* Get rid of the drive and semicolon part */

	relTo = &relTo[2];

	relFrom = &relFrom[2];

#endif

	/* Eliminate the common root between the paths */

	const char *rootTo = NULL;

	const char *rootFrom = NULL;

	while (*relTo != '\0' && *relFrom != '\0')

	{

		/* If we get to a new path sequence, start over */

		if (pathchar_sep(*relTo)

			&& pathchar_sep(*relFrom))

		{

			rootTo = relTo;

			rootFrom = relFrom;

			/* If the paths don't compare, stop looking for a common root */

		} else if (!pathchar_cmp(*relTo, *relFrom)) {

			break;

		}

		relTo++;

		relFrom++;

	}

	/* NULLs shouldn't happen! */

	if (rootTo == NULL

		|| rootFrom == NULL)

	{

		return false;

	}

	size_t numLevels = 0;

	/* The root case is special! 

	* Don't count anything from it.

	*/

	if (*(rootTo + 1) != '\0')

	{

		/* Search for how many levels we need to go up.

		* Since the root pointer points to a '/', we increment

		* the initial pointer by one.

		*/

		while (*rootTo != '\0')

		{

			if (pathchar_sep(*rootTo))

			{

				/* Check for an improper trailing slash,

				* just to be nice even though the user 

				* should NOT have done this!

				*/

				if (*(rootTo + 1) == '\0')

				{

					break;

				}

				numLevels++;

			}

			rootTo++;

		}

	}

	/* Now build the new relative path. */

	size_t len, total = 0;

	while (numLevels--)

	{

		len = _snprintf(&buffer[total], maxlength - total, ".." PLATFORM_SEP_STR);

		if (len >= maxlength - total)

		{

			/* Not enough space in the buffer */

			return false;

		}

		total += len;

	}

	/* Add the absolute path. */

	len = _snprintf(&buffer[total], maxlength - total, "%s", &rootFrom[1]);

	if (len >= maxlength - total)

	{

		return false;

	}

	return true;

}

KeyValues *SourceModBase::ReadKeyValuesHandle(Handle_t hndl, HandleError *err, bool root)

{

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		if (err)

		{

			*err = herr;

		}

		return NULL;

	}

	if (err)

	{

		*err = HandleError_None;

	}

	return (root) ? pStk->pBase : pStk->pCurRoot.front();

}

static cell_t smn_KvSetString(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key, *value;

	pCtx->LocalToStringNULL(params[2], &key);

	pCtx->LocalToString(params[3], &value);

	pStk->pCurRoot.front()->SetString(key, value);

	return 1;

}

static cell_t smn_KvSetNum(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key;

	pCtx->LocalToStringNULL(params[2], &key);

	pStk->pCurRoot.front()->SetInt(key, params[3]);

	return 1;

}

static cell_t smn_KvSetUInt64(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key;

	cell_t *addr;

	uint64 value;

	pCtx->LocalToStringNULL(params[2], &key);

	pCtx->LocalToPhysAddr(params[3], &addr);

	value = static_cast<uint64>(*addr);

	pStk->pCurRoot.front()->SetUint64(key, value);

	return 1;

}

static cell_t smn_KvSetFloat(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key;

	pCtx->LocalToStringNULL(params[2], &key);

	pStk->pCurRoot.front()->SetFloat(key, sp_ctof(params[3]));

	return 1;

}

static cell_t smn_KvSetColor(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key;

	pCtx->LocalToStringNULL(params[2], &key);

	Color color(params[3], params[4], params[5], params[6]);

	pStk->pCurRoot.front()->SetColor(key, color);

	return 1;

}

static cell_t smn_KvSetVector(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key;

	char buffer[64];

	cell_t *vector;

	pCtx->LocalToStringNULL(params[2], &key);

	pCtx->LocalToPhysAddr(params[3], &vector);

	UTIL_Format(buffer, sizeof(buffer), "%f %f %f", sp_ctof(vector[0]), sp_ctof(vector[1]), sp_ctof(vector[2]));

	pStk->pCurRoot.front()->SetString(key, buffer);

	return 1;

}

static cell_t smn_KvGetString(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	const char *value;

	char *key, *defvalue;

	pCtx->LocalToStringNULL(params[2], &key);

	pCtx->LocalToString(params[5], &defvalue);

	value = pStk->pCurRoot.front()->GetString(key, defvalue);

	pCtx->StringToLocalUTF8(params[3], params[4], value, NULL);

	return 1;

}

static cell_t smn_KvGetNum(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	int value;

	char *key;

	pCtx->LocalToStringNULL(params[2], &key);

	value = pStk->pCurRoot.front()->GetInt(key, params[3]);

	return value;

}

static cell_t smn_KvGetFloat(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	float value;

	char *key;

	pCtx->LocalToStringNULL(params[2], &key);

	value = pStk->pCurRoot.front()->GetFloat(key, sp_ctof(params[3]));

	return sp_ftoc(value);

}

static cell_t smn_KvGetColor(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	Color color;

	char *key;

	cell_t *r, *g, *b, *a;

	pCtx->LocalToStringNULL(params[2], &key);

	pCtx->LocalToPhysAddr(params[3], &r);

	pCtx->LocalToPhysAddr(params[4], &g);

	pCtx->LocalToPhysAddr(params[5], &b);

	pCtx->LocalToPhysAddr(params[6], &a);

	color = pStk->pCurRoot.front()->GetColor(key);

	*r = color.r();

	*g = color.g();

	*b = color.b();

	*a = color.a();

	return 1;

}

static cell_t smn_KvGetUInt64(IPluginContext *pCtx, const cell_t *params)

{

	Handle_t hndl = static_cast<Handle_t>(params[1]);

	HandleError herr;

	HandleSecurity sec;

	KeyValueStack *pStk;

	sec.pOwner = NULL;

	sec.pIdentity = g_pCoreIdent;

	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))

		!= HandleError_None)

	{

		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);

	}

	char *key;

	cell_t *addr, *defvalue;

	uint64 value;

	pCtx->LocalToStringNULL(params[2], &key);

	pCtx->LocalToPhysAddr(params[3], &addr);

	pCtx->LocalToPhysAddr(params[4], &defvalue);

	value = pStk->pCurRoot.front()->GetUint64(key, static_cast<uint64>(*defvalue));

	*reinterpret_cast<uint64 *>(addr) = value;

	return 1;

}

static cell_t smn_KvGetVector(IPluginContext *pCtx, const cell_t *params)

{