/**

 * vim: set ts=4 :

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

 * SourceMod Counter-Strike:Source Extension

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

#include "RegNatives.h"

#include "forwards.h"

#include "util_cstrike.h"

#include <server_class.h>

#include <iplayerinfo.h>

int g_iPriceOffset = -1;

#define REGISTER_NATIVE_ADDR(name, code) \

	void *addr; \

	if (!g_pGameConf->GetMemSig(name, &addr) || !addr) \

	{ \

		return pContext->ThrowNativeError("Failed to locate function"); \

	} \

	code; \

	g_RegNatives.Register(pWrapper);

#define GET_MEMSIG(name) \

	if (!g_pGameConf->GetMemSig(name, &addr) || !addr) \

	{ \

		return pContext->ThrowNativeError("Failed to locate function"); \

	}

inline CBaseEntity *GetCBaseEntity(int num, bool isplayer)

{

	edict_t *pEdict = gamehelpers->EdictOfIndex(num);

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

	{

		return NULL;

	}

	if (num > 0 && num <= playerhelpers->GetMaxClients())

	{

		IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(pEdict);

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

		{

			return NULL;

		}

	}

	else if (isplayer) 

	{

		return NULL;

	}

	IServerUnknown *pUnk;

	if ((pUnk=pEdict->GetUnknown()) == NULL)

	{

		return NULL;

	}

	return pUnk->GetBaseEntity();

}

bool UTIL_FindDataTable(SendTable *pTable, const char *name, sm_sendprop_info_t *info, unsigned int offset)

{

	const char *pname;

	int props = pTable->GetNumProps();

	SendProp *prop;

	SendTable *table;

	for (int i=0; i<props; i++)

	{

		prop = pTable->GetProp(i);

		if ((table = prop->GetDataTable()) != NULL)

		{

			pname = table->GetName();

			if (pname && strcmp(name, pname) == 0)

			{

				info->prop = prop;

				info->actual_offset = offset + info->prop->GetOffset();

				return true;

			}

			if (UTIL_FindDataTable(table, 

				name,

				info,

				offset + prop->GetOffset())

				)

			{

				return true;

			}

		}

	}

	return false;

}

//Taken From Sourcemod Core

unsigned int strncopy(char *dest, const char *src, size_t count)

{

	if (!count)

	{

		return 0;

	}

	char *start = dest;

	while ((*src) && (--count))

	{

		*dest++ = *src++;

	}

	*dest = '\0';

	return (dest - start);

}

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

{

	static ICallWrapper *pWrapper = NULL;

	if (!pWrapper)

	{

		REGISTER_NATIVE_ADDR("RoundRespawn", 

			pWrapper = g_pBinTools->CreateCall(addr, CallConv_ThisCall, NULL, NULL, 0));

	}

	CBaseEntity *pEntity;

	if (!(pEntity=GetCBaseEntity(params[1], true)))

	{

		return pContext->ThrowNativeError("Client index %d is not valid", params[1]);

	}

	pWrapper->Execute(&pEntity, NULL);

	return 1;

}

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

{

#if SOURCE_ENGINE != SE_CSGO || !defined(WIN32)

	static ICallWrapper *pWrapper = NULL;

	if (!pWrapper)

	{

		REGISTER_NATIVE_ADDR("SwitchTeam", 

			PassInfo pass[1]; \

			pass[0].flags = PASSFLAG_BYVAL; \

			pass[0].size = sizeof(int); \

			pass[0].type = PassType_Basic; \

			pWrapper = g_pBinTools->CreateCall(addr, CallConv_ThisCall, NULL, pass, 1))

	}

	CBaseEntity *pEntity;

	if (!(pEntity=GetCBaseEntity(params[1], true)))

	{

		return pContext->ThrowNativeError("Client index %d is not valid", params[1]);

	}

	unsigned char vstk[sizeof(CBaseEntity *) + sizeof(int)];

	unsigned char *vptr = vstk;

	*(CBaseEntity **)vptr = pEntity;

	vptr += sizeof(CBaseEntity *);

	*(int *)vptr = params[2];

	pWrapper->Execute(vstk, NULL);

#else

	if (g_pSDKTools == NULL)

	{

		return pContext->ThrowNativeError("SDKTools interface not found. SwitchTeam native disabled.");

	}

	static void *addr = NULL;

	if(!addr)

	{

		GET_MEMSIG("SwitchTeam");

	}

	void *gamerules = g_pSDKTools->GetGameRules();

	if (gamerules == NULL)

	{

		return pContext->ThrowNativeError("GameRules not available. SwitchTeam native disabled.");

	}

	CBaseEntity *pEntity;

	if (!(pEntity=GetCBaseEntity(params[1], true)))

	{

		return pContext->ThrowNativeError("Client index %d is not valid", params[1]);

	}

	int team = params[2];

	__asm

	{

		push team

		mov ecx, pEntity

		mov ebx, gamerules

		call addr

	}

#endif

	return 1;

}

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

{

	static ICallWrapper *pWrapper = NULL;

	if (!pWrapper)

	{

		REGISTER_NATIVE_ADDR("CSWeaponDrop",

			PassInfo pass[3]; \

			pass[0].flags = PASSFLAG_BYVAL; \

			pass[0].type  = PassType_Basic; \

			pass[0].size  = sizeof(CBaseEntity *); \

			pass[1].flags = PASSFLAG_BYVAL; \

			pass[1].type  = PassType_Basic; \

			pass[1].size  = sizeof(bool); \

			pass[2].flags = PASSFLAG_BYVAL; \

			pass[2].type  = PassType_Basic; \

			pass[2].size  = sizeof(bool); \

			pWrapper = g_pBinTools->CreateCall(addr, CallConv_ThisCall, NULL, pass, 3))

	}

	CBaseEntity *pEntity;

	if (!(pEntity = GetCBaseEntity(params[1], true)))

	{

		return pContext->ThrowNativeError("Client index %d is not valid", params[1]);

	}

	CBaseEntity *pWeapon;

	if (!(pWeapon = GetCBaseEntity(params[2], false)))

	{

		return pContext->ThrowNativeError("Weapon index %d is not valid", params[2]);

	}

	//Psychonic is awesome for this

	sm_sendprop_info_t spi;

	IServerUnknown *pUnk = (IServerUnknown *)pWeapon;

	IServerNetworkable *pNet = pUnk->GetNetworkable();

	if (!UTIL_FindDataTable(pNet->GetServerClass()->m_pTable, "DT_WeaponCSBase", &spi, 0))

		return pContext->ThrowNativeError("Entity index %d is not a weapon", params[2]);

	if (!gamehelpers->FindSendPropInfo("CBaseCombatWeapon", "m_hOwnerEntity", &spi))

		return pContext->ThrowNativeError("Invalid entity index %d for weapon", params[2]);

	CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pWeapon + spi.actual_offset);

	if (params[1] != hndl.GetEntryIndex() || hndl != ((IServerEntity *)pEntity)->GetRefEHandle())

		return pContext->ThrowNativeError("Weapon %d is not owned by client %d", params[2], params[1]);

	if (params[4] == 1 && g_pCSWeaponDropDetoured)

		g_pIgnoreCSWeaponDropDetour = true;

	unsigned char vstk[sizeof(CBaseEntity *) * 2 + sizeof(bool) * 2];

	unsigned char *vptr = vstk;

	// <psychonic> first one is always false. second is true to toss, false to just drop

	*(CBaseEntity **)vptr = pEntity;

	vptr += sizeof(CBaseEntity *);

	*(CBaseEntity **)vptr = pWeapon;

	vptr += sizeof(CBaseEntity *);

	*(bool *)vptr = false;

	vptr += sizeof(bool);

	*(bool *)vptr = (params[3]) ? true : false;

 	pWrapper->Execute(vstk, NULL);

	return 1;

}

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

{

	if (g_pSDKTools == NULL)

	{

		return pContext->ThrowNativeError("SDKTools interface not found. TerminateRound native disabled.");

	}

	else if (g_pSDKTools->GetInterfaceVersion() < 2)

	{

		//<psychonic> THIS ISN'T DA LIMBO STICK. LOW IS BAD

		return pContext->ThrowNativeError("SDKTools interface is outdated. TerminateRound native disabled.");

	}

	void *gamerules = g_pSDKTools->GetGameRules();

	if (gamerules == NULL)

	{

		return pContext->ThrowNativeError("GameRules not available. TerminateRound native disabled.");

	}

#if SOURCE_ENGINE != SE_CSGO || !defined(WIN32)

	static ICallWrapper *pWrapper = NULL;

	if (!pWrapper)

	{

		REGISTER_NATIVE_ADDR("TerminateRound",

			PassInfo pass[2]; \

			pass[0].flags = PASSFLAG_BYVAL; \

			pass[0].type = PassType_Basic; \

			pass[0].size = sizeof(float); \

			pass[1].flags = PASSFLAG_BYVAL; \

			pass[1].type = PassType_Basic; \

			pass[1].size = sizeof(int); \

			pWrapper = g_pBinTools->CreateCall(addr, CallConv_ThisCall, NULL, pass, 2))

	}

	if (params[3] == 1 && g_pTerminateRoundDetoured)

		g_pIgnoreTerminateDetour = true;

	unsigned char vstk[sizeof(void *) + sizeof(float)+ sizeof(int)];

	unsigned char *vptr = vstk;

	*(void **)vptr = gamerules;

	vptr += sizeof(void *);

	*(float *)vptr = sp_ctof(params[1]);

	vptr += sizeof(float);

	*(int*)vptr = params[2];

	pWrapper->Execute(vstk, NULL);

#else

	static void *addr = NULL;

	if(!addr)

	{

		GET_MEMSIG("TerminateRound");

	}

	if (params[3] == 1 && g_pTerminateRoundDetoured)

		g_pIgnoreTerminateDetour = true;

	float delay = sp_ctof(params[1]);

	int reason = params[2];

	signed int unknown = 1;//We might want to find what this is?

	__asm

	{

		push reason

		movss xmm1, delay

		mov edi, unknown

		mov ecx, gamerules

		call addr

	}

#endif

	return 1;

}

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

{

	if (!IsValidWeaponID(params[1]))

		return pContext->ThrowNativeError("Invalid WeaponID passed for this game");

	char *dest;

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

	const char *ret = WeaponIDToAlias(params[1]);

	if (ret == NULL)

	{

		return 0;

	}

	return strncopy(dest, ret, params[3]);

}

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

{

	char *weapon;

	char *dest;

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

	pContext->LocalToString(params[1], &weapon);

	const char *ret = GetTranslatedWeaponAlias(weapon);

	strncopy(dest, ret, params[3]);

	return 1;

}

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

{

	if (!IsValidWeaponID(params[2]))

		return pContext->ThrowNativeError("Invalid WeaponID passed for this game");

	int id = GetRealWeaponID(params[2]);

	//Hard code return values for weapons that dont call GetWeaponPrice and always use default value.

#if SOURCE_ENGINE == SE_CSGO

	if (id == WEAPON_C4 || id == WEAPON_KNIFE || id == WEAPON_KNIFE_GG)

		return 0;

#else

 	if (id == WEAPON_C4 || id == WEAPON_KNIFE || id == WEAPON_SHIELD)

		return 0;

	else if (id == WEAPON_KEVLAR)

		return 650;

	else if (id == WEAPON_ASSAULTSUIT)

		return 1000;

#endif

	else if (id == WEAPON_NIGHTVISION)

		return 1250;

#if SOURCE_ENGINE == SE_CSGO

	else if (id == WEAPON_DEFUSER)

		return 400;

#endif

	void *info = GetWeaponInfo(id);

	if (!info)

	{

		return pContext->ThrowNativeError("Failed to get weaponinfo");

	}

	CBaseEntity *pEntity;

	if (!(pEntity = GetCBaseEntity(params[1], true)))

	{

		return pContext->ThrowNativeError("Client index %d is not valid", params[1]);

	}

#if SOURCE_ENGINE == SE_CSGO

	static ICallWrapper *pWrapper = NULL;

	if (!pWrapper)

	{

		REGISTER_NATIVE_ADDR("GetAttributeInt",

		PassInfo pass[2]; \

		PassInfo ret; \

		pass[0].flags = PASSFLAG_BYVAL; \

		pass[0].type = PassType_Basic; \

		pass[0].size = sizeof(char *); \

		pass[1].flags = PASSFLAG_BYVAL; \

		pass[1].type = PassType_Basic; \

		pass[1].size = sizeof(CEconItemView *); \

		ret.flags = PASSFLAG_BYVAL; \

		ret.type = PassType_Basic; \

		ret.size = sizeof(int); \

		pWrapper = g_pBinTools->CreateCall(addr, CallConv_ThisCall, &ret, pass, 2))

	}

	// Get a CEconItemView for the m4

	// Found in CCSPlayer::HandleCommand_Buy_Internal

	// Linux a1 - CCSPlayer *pEntity, v5 - Player Team, a3 - ItemLoadoutSlot -1 use default loadoutslot:

	// v4 = *(int (__cdecl **)(_DWORD, _DWORD, _DWORD))(*(_DWORD *)(a1 + 9492) + 36); // offset 9

	// v6 = v4(a1 + 9492, v5, a3);

	// Windows v5 - CCSPlayer *pEntity a4 -  ItemLoadoutSlot -1 use default loadoutslot:

	// v8 = (*(int (__stdcall **)(_DWORD, int))(*(_DWORD *)(v5 + 9472) + 32))(*(_DWORD *)(v5 + 760), a4); // offset 8

	// The function is CCSPlayerInventory::GetItemInLoadout(int, int)

	// We can pass NULL view to the GetAttribute to use default loadoutslot.

	// We only really care about m4a1/m4a4 as price differs between them

	// thisPtrOffset = 9472/9492

	static ICallWrapper *pGetView = NULL;

	static int thisPtrOffset = -1;

	CEconItemView *view = NULL;

	if(!pGetView)

	{

		int offset = -1;

		int byteOffset = -1;

		void *pHandleCommandBuy = NULL;

		if (!g_pGameConf->GetOffset("GetItemInLoadout", &offset) || offset == -1)

		{

			smutils->LogError(myself, "Failed to get GetItemInLoadout offset. Reverting to NULL ItemView");

		}

		else if (!g_pGameConf->GetOffset("CCSPlayerInventoryOffset", &byteOffset) || byteOffset == -1)

		{

			smutils->LogError(myself, "Failed to get CCSPlayerInventoryOffset offset. Reverting to NULL ItemView");

		}

		else if (!g_pGameConf->GetMemSig("HandleCommand_Buy_Internal", &pHandleCommandBuy) || !pHandleCommandBuy)

		{

			smutils->LogError(myself, "Failed to get HandleCommand_Buy_Internal function. Reverting to NULL ItemView");

		}

		else

		{

			thisPtrOffset = *(int *)((intptr_t)pHandleCommandBuy + byteOffset);

			PassInfo pass[2];

			PassInfo ret;

			pass[0].flags = PASSFLAG_BYVAL;

			pass[0].type  = PassType_Basic;

			pass[0].size  = sizeof(int);

			pass[1].flags = PASSFLAG_BYVAL;

			pass[1].type  = PassType_Basic;

			pass[1].size  = sizeof(int);

			ret.flags = PASSFLAG_BYVAL;

			ret.type = PassType_Basic;

			ret.size = sizeof(void *);

			pGetView = g_pBinTools->CreateVCall(offset, 0, 0, &ret, pass, 2);

			g_RegNatives.Register(pGetView);

		}

	}

	IPlayerInfo *playerinfo = playerhelpers->GetGamePlayer(params[1])->GetPlayerInfo();

	if(pGetView && thisPtrOffset != -1 && playerinfo)

	{

		//If the gun isnt an M4 we ignore this as M4 is the only one that differs in price based on Loadout item.

		int iLoadoutSlot = -1;

		if(id == WEAPON_M4)

		{

			iLoadoutSlot = 15;

		}

		unsigned char vstk_view[sizeof(void *) + sizeof(int) * 2];

		unsigned char *vptr_view = vstk_view;

		*(void **)vptr_view = (void *)((intptr_t)pEntity + thisPtrOffset);

		vptr_view += sizeof(void *);

		*(int *)vptr_view = playerinfo->GetTeamIndex();

		vptr_view += sizeof(int);

		*(int *)vptr_view = iLoadoutSlot;

		pGetView->Execute(vstk_view, &view);

	}

	unsigned char vstk[sizeof(void *) * 2 + sizeof(char *)];

	unsigned char *vptr = vstk;

	*(void **)vptr = info;

	vptr += sizeof(void *);

	*(const char **)vptr = "in game price";

	vptr += sizeof(const char *);

	*(CEconItemView **)vptr = view;

	int price = 0;

 	pWrapper->Execute(vstk, &price);

#else

	if (g_iPriceOffset == -1)