/**

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

#include "sourcemod.h"

#include "sourcemm_api.h"

#include "PlayerManager.h"

#include "HalfLife2.h"

#include "GameConfigs.h"

#include "sm_stringutil.h"

enum PropType

{

	Prop_Send = 0,

	Prop_Data

};

enum PropFieldType

{

	PropField_Unsupported,		/**< The type is unsupported. */

	PropField_Integer,			/**< Valid for SendProp and Data fields */

	PropField_Float,			/**< Valid for SendProp and Data fields */

	PropField_Entity,			/**< Valid for Data fields only (SendProp shows as int) */

	PropField_Vector,			/**< Valid for SendProp and Data fields */

	PropField_String,			/**< Valid for SendProp and Data fields */

	PropField_String_T,			/**< Valid for Data fields.  Read only! */

};

inline edict_t *BaseEntityToEdict(CBaseEntity *pEntity)

{

	IServerUnknown *pUnk = (IServerUnknown *)pEntity;

	IServerNetworkable *pNet = pUnk->GetNetworkable();

	if (!pNet)

	{

		return NULL;

	}

	return pNet->GetEdict();

}

inline edict_t *GetEdict(cell_t num)

{

	edict_t *pEdict;

	if (!IndexToAThings(num, NULL, &pEdict))

	{

		return NULL;

	}

	return pEdict;

}

inline CBaseEntity *GetEntity(cell_t num)

{

	CBaseEntity *pEntity;

	if (!IndexToAThings(num, &pEntity, NULL))

	{

		return NULL;

	}

	return pEntity;

}

/* Given an entity reference or index, fill out a CBaseEntity and/or edict.

   If lookup is successful, returns true and writes back the two parameters.

   If lookup fails, returns false and doesn't touch the params.  */

bool IndexToAThings(cell_t num, CBaseEntity **pEntData, edict_t **pEdictData)

{

	CBaseEntity *pEntity = g_HL2.ReferenceToEntity(num);

	if (!pEntity)

	{

		return false;

	}

	int index = g_HL2.ReferenceToIndex(num);

	if (index > 0 && index <= g_Players.GetMaxClients())

	{

		CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);

		if (!pPlayer || !pPlayer->IsConnected())

		{

			return false;

		}

	}

	if (pEntData)

	{

		*pEntData = pEntity;

	}

	if (pEdictData)

	{

		edict_t *pEdict = ::BaseEntityToEdict(pEntity);

		if (!pEdict || pEdict->IsFree())

		{

			pEdict = NULL;

		}

		*pEdictData = pEdict;

	}

	return true;

}

/*

  <predcrab> AThings is like guaranteed r+ by dvander though

  <predcrab> he wont even read the rest of the patch to nit stuff

  <Fyren> Like I wasn't going to r? you anyway!

  <predcrab> he still sees!

  <predcrab> he's everywhere

*/

class VEmptyClass {};

datamap_t *VGetDataDescMap(CBaseEntity *pThisPtr, int offset)

{

	void **this_ptr = *reinterpret_cast<void ***>(&pThisPtr);

	void **vtable = *reinterpret_cast<void ***>(pThisPtr);

	void *vfunc = vtable[offset];

	union

	{

		datamap_t *(VEmptyClass::*mfpnew)();

#ifndef PLATFORM_POSIX

		void *addr;

	} u;

	u.addr = vfunc;

#else

		struct  

		{

			void *addr;

			intptr_t adjustor;

		} s;

	} u;

	u.s.addr = vfunc;

	u.s.adjustor = 0;

#endif

	return (datamap_t *)(reinterpret_cast<VEmptyClass *>(this_ptr)->*u.mfpnew)();

}

inline datamap_t *CBaseEntity_GetDataDescMap(CBaseEntity *pEntity)

{

	int offset;

	if (!g_pGameConf->GetOffset("GetDataDescMap", &offset) || !offset)

	{

		return NULL;

	}

	return VGetDataDescMap(pEntity, offset);

}

/* :TODO: Move this! */

datamap_t *CHalfLife2::GetDataMap(CBaseEntity *pEntity)

{

	return CBaseEntity_GetDataDescMap(pEntity);

}

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

{

	return gpGlobals->maxEntities;

}

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

{

	edict_t *pEdict = engine->CreateEdict();

	if (!pEdict)

	{

		return 0;

	}

	return IndexOfEdict(pEdict);

}

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

{

	edict_t *pEdict = GetEdict(params[1]);

	if (!pEdict)

	{

		return pContext->ThrowNativeError("Edict %d (%d) is not a valid edict", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	engine->RemoveEdict(pEdict);

	return 1;

}

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

{

	edict_t *pEdict = GetEdict(params[1]);

	if (!pEdict)

	{

		return 0;

	}

	/* Shouldn't be necessary... not sure though */

	return pEdict->IsFree() ? 0 : 1;

}

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

{

	CBaseEntity *pEntity = g_HL2.ReferenceToEntity(params[1]);

	return (pEntity != NULL) ? 1 : 0;

}

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

{

	edict_t *pEdict = GetEdict(params[1]);

	if (!pEdict)

	{

		return 0;

	}

	return (pEdict->GetNetworkable() != NULL) ? 1 : 0;

}

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

{

	return engine->GetEntityCount();

}

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

{

	edict_t *pEdict = GetEdict(params[1]);

	if (!pEdict)

	{

		return pContext->ThrowNativeError("Invalid edict (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	return pEdict->m_fStateFlags;

}

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

{

	edict_t *pEdict = GetEdict(params[1]);

	if (!pEdict)

	{

		return pContext->ThrowNativeError("Invalid edict (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	pEdict->m_fStateFlags = params[2];

	return 1;

}

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

{

	edict_t *pEdict = GetEdict(params[1]);

	if (!pEdict)

	{

		return pContext->ThrowNativeError("Invalid edict (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	const char *cls = pEdict->GetClassName();

	if (!cls || cls[0] == '\0')

	{

		return 0;

	}

	pContext->StringToLocal(params[2], params[3], cls);

	return 1;

}

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

{

	CBaseEntity *pEntity = g_HL2.ReferenceToEntity(params[1]);

	IServerUnknown *pUnk = (IServerUnknown *)pEntity;

	if (!pEntity)

	{

		return pContext->ThrowNativeError("Invalid entity (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	IServerNetworkable *pNet = pUnk->GetNetworkable();

	if (!pNet)

	{

		return 0;

	}

	ServerClass *pClass = pNet->GetServerClass();

	pContext->StringToLocal(params[2], params[3], pClass->GetName());

	return 1;

}

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

{

	CBaseEntity *pEntity = GetEntity(params[1]);

	if (!pEntity)

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	switch (params[3])

	{

	case 4:

		return *(int *)((uint8_t *)pEntity + offset);

	case 2:

		return *(short *)((uint8_t *)pEntity + offset);

	case 1:

		return *((uint8_t *)pEntity + offset);

	default:

		return pContext->ThrowNativeError("Integer size %d is invalid", params[3]);

	}

}

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

{

	CBaseEntity *pEntity;

	edict_t *pEdict;

	if (!IndexToAThings(params[1], &pEntity, &pEdict))

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	if (params[5] && (pEdict != NULL))

	{

		g_HL2.SetEdictStateChanged(pEdict, offset);

	}

	switch (params[4])

	{

	case 4:

		{

			*(int *)((uint8_t *)pEntity + offset) = params[3];

			break;

		}

	case 2:

		{

			*(short *)((uint8_t *)pEntity + offset) = params[3];

			break;

		}

	case 1:

		{

			*((uint8_t *)pEntity + offset) = params[3];

			break;

		}

	default:

		return pContext->ThrowNativeError("Integer size %d is invalid", params[4]);

	}

	return 1;

}

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

{

	CBaseEntity *pEntity = GetEntity(params[1]);

	if (!pEntity)

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	float f = *(float *)((uint8_t *)pEntity + offset);

	return sp_ftoc(f);

}

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

{

	CBaseEntity *pEntity;

	edict_t *pEdict;

	if (!IndexToAThings(params[1], &pEntity, &pEdict))

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	*(float *)((uint8_t *)pEntity + offset) = sp_ctof(params[3]);

	if (params[4] && (pEdict != NULL))

	{

		g_HL2.SetEdictStateChanged(pEdict, offset);

	}

	return 1;

}

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

{

	CBaseEntity *pEntity = GetEntity(params[1]);

	if (!pEntity)

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	Vector *v = (Vector *)((uint8_t *)pEntity + offset);

	cell_t *vec;

	pContext->LocalToPhysAddr(params[3], &vec);

	vec[0] = sp_ftoc(v->x);

	vec[1] = sp_ftoc(v->y);

	vec[2] = sp_ftoc(v->z);

	return 1;

}

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

{

	CBaseEntity *pEntity;

	edict_t *pEdict;

	if (!IndexToAThings(params[1], &pEntity, &pEdict))

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	Vector *v = (Vector *)((uint8_t *)pEntity + offset);

	cell_t *vec;

	pContext->LocalToPhysAddr(params[3], &vec);

	v->x = sp_ctof(vec[0]);

	v->y = sp_ctof(vec[1]);

	v->z = sp_ctof(vec[2]);

	if (params[4] && (pEdict != NULL))

	{

		g_HL2.SetEdictStateChanged(pEdict, offset);

	}

	return 1;

}

/* THIS GUY IS DEPRECATED. */

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

{

	CBaseEntity *pEntity = GetEntity(params[1]);

	if (!pEntity)

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);

	}

	CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pEntity + offset);

	if (!hndl.IsValid())

	{

		return 0;

	}

	int ref = g_HL2.IndexToReference(hndl.GetEntryIndex());

	return g_HL2.ReferenceToBCompatRef(ref);

}

int CheckBaseHandle(CBaseHandle &hndl)

{

	if (!hndl.IsValid())

	{

		return -1;

	}

	int index = hndl.GetEntryIndex();

	edict_t *pStoredEdict;

	CBaseEntity *pStoredEntity;

	if (!IndexToAThings(index, &pStoredEntity, &pStoredEdict))

	{

		return -1;

	}

	if (pStoredEdict == NULL || pStoredEntity == NULL)

	{

		return -1;

	}

	IServerEntity *pSE = pStoredEdict->GetIServerEntity();

	if (pSE == NULL)

	{

		return -1;

	}

	if (pSE->GetRefEHandle() != hndl)

	{

		return -1;

	}

	return index;

}

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

{

	CBaseEntity *pEntity = GetEntity(params[1]);

	if (pEntity == NULL)

	{

		return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);

	}

	int offset = params[2];

	if (offset <= 0 || offset > 32768)

	{

		return pContext->ThrowNativeError("Offset %d is invalid", offset);