#include <extdll.h>
#include <meta_api.h>
#include <stdarg.h>
#include <cbase.h>

#ifdef __linux__
	#include <sys/mman.h>
	#include <malloc.h>
#endif

#if _MSC_VER
	#if _MSC_VER >= 1400
		#define stricmp _stricmp
	#endif
#endif

#ifdef __linux__
	#define stricmp	strcasecmp
#endif

#ifdef _WIN32
	#define VirtFuncSpawn		0
	#define VirtFuncTakeDamage	12
#elif __linux__
	#define VirtFuncSpawn		2
	#define VirtFuncTakeDamage	14
#endif

#ifdef _WIN32
	#define PrivateToEdict(pPrivate) (*(entvars_t **)((char*)pPrivate + 4))->pContainingEntity
#elif __linux__
	#define PrivateToEdict(pPrivate) (*(entvars_t **)pPrivate)->pContainingEntity
#endif

plugin_info_t Plugin_info =
{
	META_INTERFACE_VERSION,            // ifvers
	"WPMG",                  // name
	"Alpha",                        // version
	"2011/11/7",                  // date
	"WPMG Team",                     // author
	"http://www.wpmg.ru",            // url
	"WPMG",                  // logtag, all caps please
	PT_ANYTIME,                     // (when) loadable
	PT_ANYPAUSE                     // (when) unloadable
};

meta_globals_t *gpMetaGlobals;
mutil_funcs_t *gpMetaUtilFuncs;
enginefuncs_t g_engfuncs;
globalvars_t  *gpGlobals;

bool g_bActivated = false;
bool g_bInitialized = false;

void *pOrigFuncSpawn = NULL;
void *pOrigFuncTakeDamage = NULL;

void print_srvconsole(char *fmt, ...)
{
        va_list argptr;
        static char string[384];
        va_start(argptr, fmt);
        vsnprintf(string, sizeof(string) - 1, fmt, argptr);
        string[sizeof(string) - 1] = '\0';
        va_end(argptr);
       
        SERVER_PRINT(string);
}

#ifdef _WIN32
void __fastcall HookSpawn(void *pthis)
#elif __linux__
void HookSpawn(void *pthis)
#endif
{
	print_srvconsole("::Spawn(void) %d prehook!\n", ENTINDEX(PrivateToEdict(pthis)));

#ifdef _WIN32
	reinterpret_cast<int (__fastcall *)(void *, int)>(pOrigFuncSpawn)(pthis, 0);
#elif __linux__
	reinterpret_cast<int (*)(void *)>(pOrigFuncSpawn)(pthis);
#endif

	SERVER_PRINT("::Spawn(void) posthook!\n");
}

#ifdef _WIN32
int __fastcall HookTakeDamage(void *pthis, int i, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamage)
#elif __linux__
int HookTakeDamage(void *pthis, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamage)
#endif
{
	SERVER_PRINT("::TakeDamage(int) prehook!\n");

#ifdef _WIN32
	int iOrigRet = reinterpret_cast<int (__fastcall *)(void *, int, entvars_t *, entvars_t *, float, int)>(pOrigFuncTakeDamage)(pthis, 0, pevInflictor, pevAttacker, flDamage, bitsDamage);
#elif __linux__
	int iOrigRet = reinterpret_cast<int (*)(void *, entvars_t *, entvars_t *, float, int)>(pOrigFuncTakeDamage)(pthis, pevInflictor, pevAttacker, flDamage, bitsDamage);
#endif

	SERVER_PRINT("::TakeDamage(int) posthook!\n");

	return iOrigRet;
}

void MakeHookSpawn()
{
	edict_t *pEdict = CREATE_ENTITY();

	CALL_GAME_ENTITY(PLID, "player", &pEdict->v);
	
	if (pEdict->pvPrivateData == NULL)
	{
		REMOVE_ENTITY(pEdict);
		
		return;
	}

#ifdef _WIN32
	void **vtable = *((void***)((char*)pEdict->pvPrivateData));
#elif __linux__
	void **vtable = *((void***)(((char*)pEdict->pvPrivateData) + 0x94));
#endif
	
	REMOVE_ENTITY(pEdict);
	
	if(vtable == NULL)
		return;
	
	int **ivtable = (int **)vtable;
	
	pOrigFuncSpawn = (void *)ivtable[VirtFuncSpawn];
	
#ifdef _WIN32
	DWORD OldFlags;

	VirtualProtect(&ivtable[VirtFuncSpawn], sizeof(int *), PAGE_READWRITE, &OldFlags);
#elif __linux__
	mprotect(&ivtable[VirtFuncSpawn], sizeof(int*), PROT_READ | PROT_WRITE);
#endif

	ivtable[VirtFuncSpawn] = (int *)HookSpawn;
}

void MakeHookTakeDamage()
{
	edict_t *pEdict = CREATE_ENTITY();

	CALL_GAME_ENTITY(PLID, "player", &pEdict->v);
	
	if (pEdict->pvPrivateData == NULL)
	{
		REMOVE_ENTITY(pEdict);
		
		return;
	}

#ifdef _WIN32
	void **vtable = *((void***)((char*)pEdict->pvPrivateData));
#elif __linux__
	void **vtable = *((void***)(((char*)pEdict->pvPrivateData) + 0x94));
#endif

	REMOVE_ENTITY(pEdict);
	
	if(vtable == NULL)
		return;
	
	int **ivtable = (int **)vtable;
	
	pOrigFuncTakeDamage = (void *)ivtable[VirtFuncTakeDamage];
	
#ifdef _WIN32
	DWORD OldFlags;

	VirtualProtect(&ivtable[VirtFuncTakeDamage], sizeof(int *), PAGE_READWRITE, &OldFlags);
#elif __linux__
	mprotect(&ivtable[VirtFuncTakeDamage], sizeof(int*), PROT_READ | PROT_WRITE);
#endif

	ivtable[VirtFuncTakeDamage] = (int *)HookTakeDamage;
}

void ServerActivatePost(edict_t *pEdictList, int edictCount, int clientMax)
{
	if (g_bActivated)
		RETURN_META(MRES_IGNORED);

	MakeHookSpawn();
	MakeHookTakeDamage();

	g_bActivated = true;

	RETURN_META(MRES_IGNORED);
}

void ServerDeactivatePost()
{
	if (!g_bInitialized)
		RETURN_META(MRES_IGNORED);

	g_bInitialized = false;

	RETURN_META(MRES_IGNORED);
}

void ClientCommandPost(edict_t *pEntity)
{
	const char *szArg;

	szArg = CMD_ARGV(0);

	if (stricmp(szArg, "say"))
		RETURN_META(MRES_IGNORED);

	szArg = CMD_ARGV(1);

	if (stricmp(szArg, "/damage"))
		RETURN_META(MRES_IGNORED);

#ifdef _WIN32
	reinterpret_cast<int (__fastcall *)(void *, int, entvars_t *, entvars_t *, float, int)>((*((void***)((char*)pEntity->pvPrivateData)))[VirtFuncTakeDamage])(pEntity->pvPrivateData, 0, &(pEntity->v), &(pEntity->v), 50.0, DMG_SLASH);
#elif defined __linux__
	reinterpret_cast<int (*)(void *, entvars_t *, entvars_t *, float, int)>((*((void***)(((char*)pEntity->pvPrivateData) + 0x94)))[VirtFuncTakeDamage])(pEntity->pvPrivateData, &(pEntity->v), &(pEntity->v), 50.0, DMG_SLASH);
#endif

	RETURN_META(MRES_IGNORED);
}

int SpawnPre(edict_t *pEnt)
{
	if (g_bInitialized)
		RETURN_META_VALUE(MRES_IGNORED, 0);

	g_bActivated = false;
	g_bInitialized = true;

	RETURN_META_VALUE(MRES_IGNORED, 0);
}

C_DLLEXPORT	int	Meta_Query(char	*ifvers, plugin_info_t **pPlugInfo,	mutil_funcs_t *pMetaUtilFuncs)
{
	gpMetaUtilFuncs = pMetaUtilFuncs;

	*pPlugInfo = &Plugin_info;

	return(TRUE);
}

static META_FUNCTIONS gMetaFunctionTable;
C_DLLEXPORT	int	Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs)
{
	gpMetaGlobals = pMGlobals;

	gMetaFunctionTable.pfnGetEntityAPI2 = GetEntityAPI2;
	gMetaFunctionTable.pfnGetEntityAPI2_Post = GetEntityAPI2_Post;

	memcpy(pFunctionTable, &gMetaFunctionTable, sizeof(META_FUNCTIONS));
	
	return(TRUE);
}

#ifdef __linux__
// linux prototype
C_DLLEXPORT void GiveFnptrsToDll(enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals)
{
#else
#ifdef _MSC_VER
// MSVC: Simulate __stdcall calling convention
C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll(enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals)
{
	__asm			// Prolog
	{
		// Save ebp
		push		ebp
		// Set stack frame pointer
		mov			ebp, esp
		// Allocate space for local variables
		// The MSVC compiler gives us the needed size in __LOCAL_SIZE.
		sub			esp, __LOCAL_SIZE
		// Push registers
		push		ebx
		push		esi
		push		edi
	}
#else	// _MSC_VER
#ifdef __GNUC__
// GCC can also work with this
C_DLLEXPORT void __stdcall GiveFnptrsToDll(enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals)
{
#else	// __GNUC__
// compiler not known
#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team.
#endif	// __GNUC__
#endif // _MSC_VER
#endif // __linux__

	// ** Function core <--
	memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t));
	gpGlobals = pGlobals;
	// --> ** Function core

#ifdef _MSC_VER
	// Epilog
	if (sizeof(int*) == 8)
	{	// 64 bit
		__asm
		{
			// Pop registers
			pop	edi
			pop	esi
			pop	ebx
			// Restore stack frame pointer
			mov	esp, ebp
			// Restore ebp
			pop	ebp
			// 2 * sizeof(int*) = 16 on 64 bit
			ret 16
		}
	}
	else
	{	// 32 bit
		__asm
		{
			// Pop registers
			pop	edi
			pop	esi
			pop	ebx
			// Restore stack frame pointer
			mov	esp, ebp
			// Restore ebp
			pop	ebp
			// 2 * sizeof(int*) = 8 on 32 bit
			ret 8
		}
	}
#endif // #ifdef _MSC_VER
}

DLL_FUNCTIONS gFunctionTable;
C_DLLEXPORT	int	GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
{
	memset(&gFunctionTable, 0, sizeof(DLL_FUNCTIONS));

	gFunctionTable.pfnSpawn = SpawnPre;

	memcpy(pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS));

	return 1;
}

DLL_FUNCTIONS gFunctionTable_Post;
C_DLLEXPORT	int	GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
{
	memset(&gFunctionTable_Post, 0, sizeof(DLL_FUNCTIONS));

	gFunctionTable_Post.pfnServerActivate = ServerActivatePost;
	gFunctionTable_Post.pfnServerDeactivate = ServerDeactivatePost;
	gFunctionTable_Post.pfnClientCommand = ClientCommandPost;

	memcpy(pFunctionTable, &gFunctionTable_Post, sizeof(DLL_FUNCTIONS));

	return 1;
}