/**

 * vim: set ts=4 :

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

 * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.

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

 *

 * This file is not open source and may not be copied without explicit

 * written permission of AlliedModders LLC.  This file may not be redistributed 

 * in whole or significant part.

 * For information, see LICENSE.txt or http://www.sourcemod.net/license.php

 *

 * Version: $Id$

 */

#include "sourcemod.h"

#include "sourcemm_api.h"

#include "sm_stringutil.h"

#include "HandleSys.h"

#include <KeyValues.h>

HandleType_t g_KeyValueType;

struct KeyValueStack 

{

	KeyValues *pBase;

	CStack<KeyValues *> pCurRoot;

};

class KeyValuekNatives : 

	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;

	}

};

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->LocalToString(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->LocalToString(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->LocalToString(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->LocalToString(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->LocalToString(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_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->LocalToString(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->LocalToString(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->LocalToString(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->LocalToString(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->LocalToString(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_CreateKeyValues(IPluginContext *pCtx, const cell_t *params)

{

	KeyValueStack *pStk;

	char *name, *firstkey, *firstvalue;

	bool is_empty;

	pCtx->LocalToString(params[1], &name);

	pCtx->LocalToString(params[2], &firstkey);

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

	is_empty = (firstkey[0] == '\0');

	pStk = new KeyValueStack;

	pStk->pBase = new KeyValues(name, is_empty ? NULL : firstkey, (is_empty||(firstvalue[0]=='\0')) ? NULL : firstvalue);

	pStk->pCurRoot.push(pStk->pBase);

	return g_HandleSys.CreateHandle(g_KeyValueType, pStk, pCtx->GetIdentity(), g_pCoreIdent, NULL);

}

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

{

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

	HandleError herr;

	HandleSecurity sec;

	char *name;	

	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);

	}

	pCtx->LocalToString(params[2], &name);

	KeyValues *pSubKey = pStk->pBase->FindKey(name, (params[3]) ? true : false);

	if (!pSubKey)

	{

		return 0;

	}

	pStk->pCurRoot.push(pSubKey);

	return 1;

}

static cell_t smn_KvJumpFirstSubKey(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);

	}

	KeyValues *pSubKey = pStk->pCurRoot.front();

	KeyValues *pFirstSubKey = pSubKey->GetFirstSubKey();

	if (!pFirstSubKey)

	{

		return 0;

	}

	pStk->pCurRoot.push(pFirstSubKey);

	return 1;

}

static cell_t smn_KvJumpNextSubKey(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);

	}

	KeyValues *pSubKey = pStk->pCurRoot.front();

	KeyValues *pNextKey = pSubKey->GetNextKey();

	if (!pNextKey)

	{

		return 0;

	}

	pStk->pCurRoot.push(pNextKey);

	return 1;	

}

static cell_t smn_KvGoBack(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);

	}

	if (pStk->pCurRoot.size() == 1)

	{

		return 0;

	}

	pStk->pCurRoot.pop();

	return 1;

}

static cell_t smn_KvRewind(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);

	}

	while (pStk->pCurRoot.size() > 1)

	{

		pStk->pCurRoot.pop();

	}

	return 1;

}

static cell_t smn_KvGetSectionName(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);

	}

	KeyValues *pSection = pStk->pCurRoot.front();

	const char *name = pSection->GetName();

	if (!name)

	{

		return 0;

	}

	pCtx->StringToLocalUTF8(params[2], params[3], name, NULL);

	return 1;

}

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

{

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

	HandleError herr;

	HandleSecurity sec;

	char *name;

	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);

	}

	pCtx->LocalToString(params[2], &name);

	KeyValues *pSection = pStk->pCurRoot.front();

	pSection->SetName(name);

	return 1;

}

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

{

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

	HandleError herr;

	HandleSecurity sec;

	char *name;

	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);