/**

 * vim: set ts=4 :

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

 * Source SDK Hooks Extension

 * Copyright (C) 2010-2012 Nicholas Hastings

 * Copyright (C) 2009-2010 Erik Minekus

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

 *

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

#include "extension.h"

#include "compat_wrappers.h"

#include "macros.h"

#include "natives.h"

#include <sm_platform.h>

#include <const.h>

//#define SDKHOOKSDEBUG

/**

 * Globals

 */

// Order MUST match SDKHookType enum

HookTypeData g_HookTypes[SDKHook_MAXHOOKS] = 

{

//   Hook name                DT required               Supported (always false til later)

	{"EndTouch",              "",                       false},

	{"FireBulletsPost",       "",                       false},

	{"OnTakeDamage",          "",                       false},

	{"OnTakeDamagePost",      "",                       false},

	{"PreThink",              "DT_BasePlayer",          false},

	{"PostThink",             "DT_BasePlayer",          false},

	{"SetTransmit",           "",                       false},

	{"Spawn",                 "",                       false},

	{"StartTouch",            "",                       false},

	{"Think",                 "",                       false},

	{"Touch",                 "",                       false},

	{"TraceAttack",           "",                       false},

	{"TraceAttackPost",       "",                       false},

	{"WeaponCanSwitchTo",     "DT_BaseCombatCharacter", false},

	{"WeaponCanUse",          "DT_BaseCombatCharacter", false},

	{"WeaponDrop",            "DT_BaseCombatCharacter", false},

	{"WeaponEquip",           "DT_BaseCombatCharacter", false},

	{"WeaponSwitch",          "DT_BaseCombatCharacter", false},

	{"ShouldCollide",         "",                       false},

	{"PreThinkPost",          "DT_BasePlayer",          false},

	{"PostThinkPost",         "DT_BasePlayer",          false},

	{"ThinkPost",             "",                       false},

	{"EndTouchPost",          "",                       false},

	{"GroundEntChangedPost",  "",                       false},

	{"SpawnPost",             "",                       false},

	{"StartTouchPost",        "",                       false},

	{"TouchPost",             "",                       false},

	{"VPhysicsUpdate",        "",                       false},

	{"VPhysicsUpdatePost",    "",                       false},

	{"WeaponCanSwitchToPost", "DT_BaseCombatCharacter", false},

	{"WeaponCanUsePost",      "DT_BaseCombatCharacter", false},

	{"WeaponDropPost",        "DT_BaseCombatCharacter", false},

	{"WeaponEquipPost",       "DT_BaseCombatCharacter", false},

	{"WeaponSwitchPost",      "DT_BaseCombatCharacter", false},

	{"Use",                   "",                       false},

	{"UsePost",               "",                       false},

	{"Reload",                "DT_BaseCombatWeapon",    false},

	{"ReloadPost",            "DT_BaseCombatWeapon",    false},

	{"GetMaxHealth",          "",                       false},

};

SDKHooks g_Interface;

SMEXT_LINK(&g_Interface);

CGlobalVars *gpGlobals;

ke::Vector<CVTableList *> g_HookList[SDKHook_MAXHOOKS];

CBitVec<NUM_ENT_ENTRIES> m_EntityExists;

IBinTools *g_pBinTools = NULL;

ICvar *icvar = NULL;

// global hooks and forwards

IForward *g_pOnEntityCreated = NULL;

IForward *g_pOnEntityDestroyed = NULL;

#ifdef GAMEDESC_CAN_CHANGE

int g_hookOnGetGameDescription = 0;

IForward *g_pOnGetGameNameDescription = NULL;

#endif

int g_hookOnGetMapEntitiesString = 0;

int g_hookOnLevelInit = 0;

IForward *g_pOnLevelInit = NULL;

IGameConfig *g_pGameConf = NULL;

char g_szMapEntities[2097152];

CUtlVector<IEntityListener *> *EntListeners()

{

	void *gEntList = gamehelpers->GetGlobalEntityList();

	if (gEntList)

	{

		int offset = -1; /* 65572 */

		if (g_pGameConf->GetOffset("EntityListeners", &offset))

		{

			return (CUtlVector<IEntityListener *> *)((intptr_t) gEntList + offset);

		}

	}

	else

	{

		void *entListeners;

		if (g_pGameConf->GetAddress("EntityListenersPtr", &entListeners))

		{

			return (CUtlVector<IEntityListener *> *)entListeners;

		}

	}

	return NULL;

}

/**

 * IServerGameDLL & IVEngineServer Hooks

 */

SH_DECL_HOOK6(IServerGameDLL, LevelInit, SH_NOATTRIB, 0, bool, const char *, const char *, const char *, const char *, bool, bool);

#ifdef GAMEDESC_CAN_CHANGE

SH_DECL_HOOK0(IServerGameDLL, GetGameDescription, SH_NOATTRIB, 0, const char *);

#endif

SH_DECL_HOOK0(IVEngineServer, GetMapEntitiesString, SH_NOATTRIB, 0, const char *);

/**

 * CBaseEntity Hooks

 */

SH_DECL_MANUALHOOK1_void(EndTouch, 0, 0, 0, CBaseEntity *);

SH_DECL_MANUALHOOK1_void(FireBullets, 0, 0, 0, FireBulletsInfo_t const&);

#ifdef GETMAXHEALTH_IS_VIRTUAL

SH_DECL_MANUALHOOK0(GetMaxHealth, 0, 0, 0, int);

#endif

SH_DECL_MANUALHOOK0_void(GroundEntChanged, 0, 0, 0);

SH_DECL_MANUALHOOK1(OnTakeDamage, 0, 0, 0, int, CTakeDamageInfoHack &);

SH_DECL_MANUALHOOK0_void(PreThink, 0, 0, 0);

SH_DECL_MANUALHOOK0_void(PostThink, 0, 0, 0);

SH_DECL_MANUALHOOK0(Reload, 0, 0, 0, bool);

SH_DECL_MANUALHOOK2_void(SetTransmit, 0, 0, 0, CCheckTransmitInfo *, bool);

SH_DECL_MANUALHOOK2(ShouldCollide, 0, 0, 0, bool, int, int);

#if SOURCE_ENGINE == SE_DOTA

SH_DECL_MANUALHOOK1_void(Spawn, 0, 0, 0, CEntityKeyValues *);

#else

SH_DECL_MANUALHOOK0_void(Spawn, 0, 0, 0);

#endif

SH_DECL_MANUALHOOK1_void(StartTouch, 0, 0, 0, CBaseEntity *);

SH_DECL_MANUALHOOK0_void(Think, 0, 0, 0);

SH_DECL_MANUALHOOK1_void(Touch, 0, 0, 0, CBaseEntity *);

#if SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS || SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_TF2 || SOURCE_ENGINE == SE_SDK2013

SH_DECL_MANUALHOOK4_void(TraceAttack, 0, 0, 0, CTakeDamageInfoHack &, const Vector &, CGameTrace *, CDmgAccumulator *);

#else

SH_DECL_MANUALHOOK3_void(TraceAttack, 0, 0, 0, CTakeDamageInfoHack &, const Vector &, CGameTrace *);

#endif

SH_DECL_MANUALHOOK4_void(Use, 0, 0, 0, CBaseEntity *, CBaseEntity *, USE_TYPE, float);

SH_DECL_MANUALHOOK1_void(VPhysicsUpdate, 0, 0, 0, IPhysicsObject *);

SH_DECL_MANUALHOOK1(Weapon_CanSwitchTo, 0, 0, 0, bool, CBaseCombatWeapon *);

SH_DECL_MANUALHOOK1(Weapon_CanUse, 0, 0, 0, bool, CBaseCombatWeapon *);

SH_DECL_MANUALHOOK3_void(Weapon_Drop, 0, 0, 0, CBaseCombatWeapon *, const Vector *, const Vector *);

SH_DECL_MANUALHOOK1_void(Weapon_Equip, 0, 0, 0, CBaseCombatWeapon *);

SH_DECL_MANUALHOOK2(Weapon_Switch, 0, 0, 0, bool, CBaseCombatWeapon *, int);

/**

 * Forwards

 */

bool SDKHooks::SDK_OnLoad(char *error, size_t maxlength, bool late)

{

	char buffer[256];

	g_pSM->BuildPath(Path_SM, buffer, sizeof(buffer)-1, "/extensions/sdkhooks.ext." PLATFORM_LIB_EXT);

	if (libsys->PathExists(buffer) && libsys->IsPathFile(buffer))

	{

		g_pSM->Format(error, maxlength-1, "SDKHooks 2.x cannot load while old version (sdkhooks.ext." PLATFORM_LIB_EXT ") is still in extensions dir");

		return false;

	}

	g_pSM->BuildPath(Path_SM, buffer, sizeof(buffer)-1, "/gamedata/sdkhooks.games.txt");

	if (libsys->PathExists(buffer) && libsys->IsPathFile(buffer))

	{

		g_pSM->Format(error, maxlength-1, "SDKHooks 2.x cannot load while old gamedata file (sdkhooks.games.txt) is still in gamedata dir");

		return false;

	}

	sharesys->AddDependency(myself, "bintools.ext", true, true);

	sharesys->AddNatives(myself, g_Natives);

	sharesys->RegisterLibrary(myself, "sdkhooks");

	sharesys->AddInterface(myself, &g_Interface);

	sharesys->AddCapabilityProvider(myself, this, "SDKHook_DmgCustomInOTD");

	sharesys->AddCapabilityProvider(myself, this, "SDKHook_LogicalEntSupport");

	playerhelpers->AddClientListener(&g_Interface);

	plsys->AddPluginsListener(&g_Interface);

	g_pOnEntityCreated = forwards->CreateForward("OnEntityCreated", ET_Ignore, 2, NULL, Param_Cell, Param_String);

	g_pOnEntityDestroyed = forwards->CreateForward("OnEntityDestroyed", ET_Ignore, 1, NULL, Param_Cell);

#ifdef GAMEDESC_CAN_CHANGE

	g_pOnGetGameNameDescription = forwards->CreateForward("OnGetGameDescription", ET_Hook, 2, NULL, Param_String);

#endif

	g_pOnLevelInit = forwards->CreateForward("OnLevelInit", ET_Hook, 2, NULL, Param_String, Param_String);

	buffer[0] = '\0';

	if (!gameconfs->LoadGameConfigFile("sdkhooks.games", &g_pGameConf, buffer, sizeof(buffer)))

	{

		if (buffer[0])

		{

			g_pSM->Format(error, maxlength, "Could not read sdkhooks.games gamedata: %s", buffer);

		}

		return false;

	}

	CUtlVector<IEntityListener *> *entListeners = EntListeners();

	if (!entListeners)

	{

		g_pSM->Format(error, maxlength, "Failed to setup entity listeners");

		return false;

	}

	entListeners->AddToTail(this);

	SetupHooks();

#if SOURCE_ENGINE >= SE_ORANGEBOX

	int index;

	CBaseHandle hndl;

	for (IHandleEntity *pEnt = (IHandleEntity *)servertools->FirstEntity(); pEnt; pEnt = (IHandleEntity *)servertools->NextEntity((CBaseEntity *)pEnt))

	{

		hndl = pEnt->GetRefEHandle();

		if (!hndl.IsValid())

			continue;

		index = hndl.GetEntryIndex();

		m_EntityExists.Set(index);

	}

#else

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

	{

		if (gamehelpers->ReferenceToEntity(i) != NULL)

			m_EntityExists.Set(i);

	}

#endif

	return true;

}

inline void HookLevelInit()

{

	assert(g_hookOnLevelInit == 0);

	g_hookOnLevelInit = SH_ADD_HOOK(IServerGameDLL, LevelInit, gamedll, SH_MEMBER(&g_Interface, &SDKHooks::Hook_LevelInit), false);

	assert(g_hookOnGetMapEntitiesString == 0);

	g_hookOnGetMapEntitiesString = SH_ADD_HOOK(IVEngineServer, GetMapEntitiesString, engine, SH_MEMBER(&g_Interface, &SDKHooks::Hook_GetMapEntitiesString), false);

}

#ifdef GAMEDESC_CAN_CHANGE

inline void HookGetGameDescription()

{

	assert(g_hookOnGetGameDescription == 0);

	g_hookOnGetGameDescription = SH_ADD_HOOK(IServerGameDLL, GetGameDescription, gamedll, SH_MEMBER(&g_Interface, &SDKHooks::Hook_GetGameDescription), false);

}

#endif

void SDKHooks::SDK_OnAllLoaded()

{

	SM_GET_LATE_IFACE(BINTOOLS, g_pBinTools);

	if (!g_pBinTools)

	{

		g_pSM->LogError(myself, "Could not find interface: " SMINTERFACE_BINTOOLS_NAME);

		return;

	}

	if (g_pOnLevelInit->GetFunctionCount() > 0)

		HookLevelInit();

#ifdef GAMEDESC_CAN_CHANGE

	if (g_pOnGetGameNameDescription->GetFunctionCount() > 0)

		HookGetGameDescription();

#endif

}

#define KILL_HOOK_IF_ACTIVE(hook) \

	if (hook != 0) \

	{ \

		SH_REMOVE_HOOK_ID(hook); \

	}

void SDKHooks::SDK_OnUnload()

{

	// Remove left over hooks

	Unhook(reinterpret_cast<SourcePawn::IPluginContext *>(NULL));

	KILL_HOOK_IF_ACTIVE(g_hookOnLevelInit);

	KILL_HOOK_IF_ACTIVE(g_hookOnGetMapEntitiesString);

#ifdef GAMEDESC_CAN_CHANGE

	KILL_HOOK_IF_ACTIVE(g_hookOnGetGameDescription);

#endif

	forwards->ReleaseForward(g_pOnEntityCreated);

	forwards->ReleaseForward(g_pOnEntityDestroyed);

#ifdef GAMEDESC_CAN_CHANGE

	forwards->ReleaseForward(g_pOnGetGameNameDescription);

#endif

	forwards->ReleaseForward(g_pOnLevelInit);

	plsys->RemovePluginsListener(&g_Interface);

	playerhelpers->RemoveClientListener(&g_Interface);

	sharesys->DropCapabilityProvider(myself, this, "SDKHook_DmgCustomInOTD");

	sharesys->DropCapabilityProvider(myself, this, "SDKHook_LogicalEntSupport");

	CUtlVector<IEntityListener *> *entListeners = EntListeners();

	entListeners->FindAndRemove(this);

	gameconfs->CloseGameConfigFile(g_pGameConf);

}

bool SDKHooks::SDK_OnMetamodLoad(ISmmAPI *ismm, char *error, size_t maxlen, bool late)

{

	GET_V_IFACE_CURRENT(GetEngineFactory, icvar, ICvar, CVAR_INTERFACE_VERSION);

#if SOURCE_ENGINE >= SE_ORANGEBOX

	g_pCVar = icvar;

#endif

	CONVAR_REGISTER(this);

	gpGlobals = ismm->GetCGlobals();

	return true;

}

const char *SDKHooks::GetExtensionVerString()

{

	return SOURCEMOD_VERSION;

}

const char *SDKHooks::GetExtensionDateString()

{

	return SOURCEMOD_BUILD_TIME;

}

void SDKHooks::OnPluginLoaded(IPlugin *plugin)

{

	if (g_pOnLevelInit->GetFunctionCount() > 0 && g_hookOnLevelInit == 0)

		HookLevelInit();

#ifdef GAMEDESC_CAN_CHANGE

	if (g_pOnGetGameNameDescription->GetFunctionCount() > 0 && g_hookOnGetGameDescription == 0)

		HookGetGameDescription();

#endif

}

void SDKHooks::OnPluginUnloaded(IPlugin *plugin)

{

	Unhook(plugin->GetBaseContext());

	if (g_pOnLevelInit->GetFunctionCount() == 0)

	{

		KILL_HOOK_IF_ACTIVE(g_hookOnLevelInit);

		KILL_HOOK_IF_ACTIVE(g_hookOnGetMapEntitiesString);

	}

#ifdef GAMEDESC_CAN_CHANGE

	if (g_pOnGetGameNameDescription->GetFunctionCount() == 0)

		KILL_HOOK_IF_ACTIVE(g_hookOnGetGameDescription);

#endif

}

void SDKHooks::OnClientPutInServer(int client)

{

	CBaseEntity *pPlayer = gamehelpers->ReferenceToEntity(client);

	const char *pName = gamehelpers->GetEntityClassname(pPlayer);

	// Send OnEntityCreated to SM listeners

	SourceHook::List<ISMEntityListener *>::iterator iter;

	ISMEntityListener *pListener = NULL;

	for (iter=m_EntListeners.begin(); iter!=m_EntListeners.end(); iter++)

	{

		pListener = (*iter);

		pListener->OnEntityCreated(pPlayer, pName ? pName : "");

	}

	// Call OnEntityCreated forward

	g_pOnEntityCreated->PushCell(client);

	g_pOnEntityCreated->PushString(pName ? pName : "");

	g_pOnEntityCreated->Execute(NULL);

	m_EntityExists.Set(client);

}

void SDKHooks::AddEntityListener(ISMEntityListener *listener)

{

	m_EntListeners.push_back(listener);

}

void SDKHooks::RemoveEntityListener(ISMEntityListener *listener)

{

	m_EntListeners.remove(listener);

}

bool SDKHooks::RegisterConCommandBase(ConCommandBase *pVar)

{

	/* Always call META_REGCVAR instead of going through the engine. */

	return META_REGCVAR(pVar);

}

FeatureStatus SDKHooks::GetFeatureStatus(FeatureType type, const char *name)

{

	return FeatureStatus_Available;

}

/**

 * Functions

 */

cell_t SDKHooks::Call(int entity, SDKHookType type, int other)

{

	return Call(gamehelpers->ReferenceToEntity(entity), type, gamehelpers->ReferenceToEntity(other));

}

cell_t SDKHooks::Call(CBaseEntity *pEnt, SDKHookType type, int other)

{

	return Call(pEnt, type, gamehelpers->ReferenceToEntity(other));

}

cell_t SDKHooks::Call(CBaseEntity *pEnt, SDKHookType type, CBaseEntity *pOther)

{

	cell_t ret = Pl_Continue;

	CVTableHook vhook(pEnt);

	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[type];

	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)

	{

		if (vhook != vtablehooklist[entry]->vtablehook)

		{

			continue;

		}

		ke::Vector<HookList> &pawnlist = vtablehooklist[entry]->hooks;

		int entity = gamehelpers->EntityToBCompatRef(pEnt);

		int other = gamehelpers->EntityToBCompatRef(pOther);

		for (entry = 0; entry < pawnlist.length(); ++entry)

		{

			if (entity != pawnlist[entry].entity)

			{

				continue;

			}

			IPluginFunction *callback = pawnlist[entry].callback;

			callback->PushCell(entity);

			callback->PushCell(other);

			cell_t res;

			callback->Execute(&res);

			if(res > ret)

			{

				ret = res;

			}

		}

		break;

	}

	return ret;

}

void SDKHooks::SetupHooks()

{

	int offset;

	//			gamedata          pre    post

	// (pre is not necessarily a prehook, just named without "Post" appeneded)

	CHECKOFFSET(EndTouch,         true,  true);

	CHECKOFFSET(FireBullets,      false, true);

	CHECKOFFSET(GroundEntChanged, false, true);

	CHECKOFFSET(OnTakeDamage,     true,  true);

	CHECKOFFSET(PreThink,         true,  true);

	CHECKOFFSET(PostThink,        true,  true);

	CHECKOFFSET(Reload,           true,  true);

	CHECKOFFSET(SetTransmit,      true,  false);

	CHECKOFFSET(ShouldCollide,    true,  false);

	CHECKOFFSET(Spawn,            true,  true);

	CHECKOFFSET(StartTouch,       true,  true);

	CHECKOFFSET(Think,            true,  true);

	CHECKOFFSET(Touch,            true,  true);

	CHECKOFFSET(TraceAttack,      true,  true);

	CHECKOFFSET(Use,              true,  true);

	CHECKOFFSET_W(CanSwitchTo,    true,  true);

	CHECKOFFSET_W(CanUse,         true,  true);

	CHECKOFFSET_W(Drop,           true,  true);

	CHECKOFFSET_W(Equip,          true,  true);

	CHECKOFFSET_W(Switch,         true,  true);

	CHECKOFFSET(VPhysicsUpdate,   true,  true);

	// this one is in a class all its own -_-

	offset = 0;

	g_pGameConf->GetOffset("GroundEntChanged", &offset);

	if (offset > 0)

	{

		SH_MANUALHOOK_RECONFIGURE(GroundEntChanged, offset, 0, 0);

		g_HookTypes[SDKHook_GroundEntChangedPost].supported = true;

	}

#ifdef GETMAXHEALTH_IS_VIRTUAL

	CHECKOFFSET(GetMaxHealth,	true,	false);

#endif

}

HookReturn SDKHooks::Hook(int entity, SDKHookType type, IPluginFunction *callback)

{

	if(!g_HookTypes[type].supported)

		return HookRet_NotSupported;

	CBaseEntity *pEnt = gamehelpers->ReferenceToEntity(entity);

	if(!pEnt)

		return HookRet_InvalidEntity;

	if(type < 0 || type >= SDKHook_MAXHOOKS)

		return HookRet_InvalidHookType;

	if (!!strcmp(g_HookTypes[type].dtReq, ""))

	{

		IServerUnknown *pUnk = (IServerUnknown *)pEnt;