/**
 * vim: set ts=4 :
 * =============================================================================
 * SourceMod SDKTools Extension
 * Copyright (C) 2004-2007 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: tenatives.cpp 1566 2007-10-14 22:12:46Z faluco $
 */

#include "extension.h"
#include "output.h"

ISourcePawnEngine *spengine = NULL;
EntityOutputManager g_OutputManager;

bool EntityOutputManager::CreateFireEventDetour()
{
	if (!g_pGameConf->GetMemSig("FireOutput", &info_address) || !info_address)
	{
		g_pSM->LogError(myself, "Could not locate FireOutput - Disabling Entity Outputs");
		return false;
	}

	if (!g_pGameConf->GetOffset("FireOutputBackup", (int *)&(info_restore.bytes)))
	{
		g_pSM->LogError(myself, "Could not locate FireOutputBackup - Disabling Entity Outputs");
		return false;
	}

	/* First, save restore bits */
	for (size_t i=0; i<info_restore.bytes; i++)
	{
		info_restore.patch[i] = ((unsigned char *)info_address)[i];
	}

	info_callback = spengine->ExecAlloc(100);
	JitWriter wr;
	JitWriter *jit = &wr;
	wr.outbase = (jitcode_t)info_callback;
	wr.outptr = wr.outbase;

	/* Function we are detouring into is
	 *
	 * void FireEventDetour(CBaseEntityOutput(void *) *pOutput, CBaseEntity *pActivator, CBaseEntity *pCaller, float fDelay = 0 )
	 */

	/* push		fDelay [esp+20h]
	 * push		pCaller [esp+1Ch]
	 * push		pActivator [esp+18h]
	 * push		pOutput [ecx]
	 */


#if defined PLATFORM_WINDOWS

	IA32_Push_Rm_Disp8_ESP(jit, 32);
	IA32_Push_Rm_Disp8_ESP(jit, 32);
	IA32_Push_Rm_Disp8_ESP(jit, 32);

	/* variant_t doesnt do anything so i'll disable this bit */
	//IA32_Push_Rm_Disp8_ESP(jit, 32);
	//IA32_Push_Rm_Disp8_ESP(jit, 32);
	//IA32_Push_Rm_Disp8_ESP(jit, 32);
	//IA32_Push_Rm_Disp8_ESP(jit, 32); 
	//IA32_Push_Rm_Disp8_ESP(jit, 32);

	IA32_Push_Reg(jit, REG_ECX);

#elif defined PLATFORM_LINUX
	IA32_Push_Rm_Disp8_ESP(jit, 20);
	IA32_Push_Rm_Disp8_ESP(jit, 20);
	IA32_Push_Rm_Disp8_ESP(jit, 20);
	// We miss the variant_t pointer
	IA32_Push_Rm_Disp8_ESP(jit, 16);
#endif

	jitoffs_t call = IA32_Call_Imm32(jit, 0); 
	IA32_Write_Jump32_Abs(jit, call, (void *)TempDetour);

	
#if defined PLATFORM_LINUX
	IA32_Add_Rm_Imm8(jit, REG_ESP, 4, MOD_REG);		//add esp, 4
#elif defined PLATFORM_WINDOWS
	IA32_Pop_Reg(jit, REG_ECX);
#endif

	IA32_Add_Rm_Imm8(jit, REG_ESP, 12, MOD_REG);	//add esp, 12 (0Ch)


	/* Patch old bytes in */
	for (size_t i=0; i<info_restore.bytes; i++)
	{
		jit->write_ubyte(info_restore.patch[i]);
	}

	/* Return to the original function */
	call = IA32_Jump_Imm32(jit, 0);
	IA32_Write_Jump32_Abs(jit, call, (unsigned char *)info_address + info_restore.bytes);

	return true;
}

void EntityOutputManager::InitFireEventDetour()
{
	if (!is_detoured)
	{
		DoGatePatch((unsigned char *)info_address, &info_callback);
		is_detoured = true;
	}
}

void EntityOutputManager::DeleteFireEventDetour()
{
	if (is_detoured)
	{
		ShutdownFireEventDetour();
	}

	if (info_callback)
	{
		/* Free the gate */
		spengine->ExecFree(info_callback);
		info_callback = NULL;
	}
}

void TempDetour(void *pOutput, CBaseEntity *pActivator, CBaseEntity *pCaller, float fDelay)
{
	g_OutputManager.FireEventDetour(pOutput, pActivator, pCaller, fDelay);
}

void EntityOutputManager::ShutdownFireEventDetour()
{
	if (info_callback)
	{
		/* Remove the patch */
		ApplyPatch(info_address, 0, &info_restore, NULL);
		is_detoured = false;
	}
}

void EntityOutputManager::FireEventDetour(void *pOutput, CBaseEntity *pActivator, CBaseEntity *pCaller, float fDelay)
{
	char sOutput[20];
	Q_snprintf(sOutput, sizeof(sOutput), "%x", pOutput);

	// attempt to directly lookup a hook using the pOutput pointer
	OutputNameStruct *pOutputName = NULL;

	edict_t *pEdict = gameents->BaseEntityToEdict(pCaller);

	/* TODO: Add support for entities without an edict */
	if (pEdict == NULL)
	{
		return;
	}

	bool fastLookup = false;
	
	// Fast lookup failed - check the slow way for hooks that havn't fired yet
	if ((fastLookup = EntityOutputs->Retrieve(sOutput, (void **)&pOutputName)) == false)
	{
		const char *classname = pEdict->GetClassName();
		const char *outputname = FindOutputName(pOutput, pCaller);

		pOutputName = FindOutputPointer(classname, outputname, false);

		if (!pOutputName)
		{
			return;
		}
	}

	if (!pOutputName->hooks.empty())
	{
		if (!fastLookup)
		{
			// hook exists on this classname and output - map it into our quick find trie
			EntityOutputs->Insert(sOutput, pOutputName);
		}

		SourceHook::List<omg_hooks *>::iterator _iter;

		omg_hooks *hook;

		_iter = pOutputName->hooks.begin();

		while (_iter != pOutputName->hooks.end())
		{
			hook = (omg_hooks *)*_iter;

			hook->in_use = true;

			int serial = pEdict->m_NetworkSerialNumber;
			
			if (serial != hook->entity_filter && hook->entity_index == engine->IndexOfEdict(pEdict))
			{
				// same entity index but different serial number. Entity has changed, kill the hook.
				_iter = pOutputName->hooks.erase(_iter);
				CleanUpHook(hook);

				continue;
			}

			if (hook->entity_filter == -1 || hook->entity_filter == serial) // Global classname hook
			{
				/*
				Handle_t handle;

				if (Value.FieldType() == FIELD_VOID)
				{
					handle = 0;
				}
				else
				{
					varhandle_t *varhandle = new varhandle_t;
					memmove ((void *)&varhandle->crab, (void *)&Value, sizeof(variant_t));

					handle = handlesys->CreateHandle(VariantHandle, (void *)varhandle, hook->pf->GetParentContext()->GetIdentity(), myself->GetIdentity(), NULL);
				}
				*/

				//fire the forward to hook->pf
				hook->pf->PushString(pOutputName->Name);
				hook->pf->PushCell(engine->IndexOfEdict(pEdict));
				
				edict_t *pEdictActivator = gameents->BaseEntityToEdict(pActivator);
				if (!pEdictActivator)
				{
					hook->pf->PushCell(-1);
				}
				else
				{
					hook->pf->PushCell(engine->IndexOfEdict(pEdictActivator));
				}
				//hook->pf->PushCell(handle);
				hook->pf->PushFloat(fDelay);
				hook->pf->Execute(NULL);

				if ((hook->entity_filter != -1) && hook->only_once)
				{
					_iter = pOutputName->hooks.erase(_iter);
					CleanUpHook(hook);

					continue;
				}

				if (hook->delete_me)
				{
					_iter = pOutputName->hooks.erase(_iter);
					CleanUpHook(hook);
					continue;
				}

				hook->in_use = false;
				_iter++;

				continue;
			}
		}
	}
}

omg_hooks *EntityOutputManager::NewHook()
{
	omg_hooks *hook;

	if (FreeHooks.empty())
	{
		hook = new omg_hooks;
	}
	else
	{
		hook = g_OutputManager.FreeHooks.front();
		g_OutputManager.FreeHooks.pop();
	}

	return hook;
}

void EntityOutputManager::OnHookAdded()
{
	HookCount++;

	if (HookCount == 1)
	{
		// This is the first hook created
		InitFireEventDetour();
	}
}

void EntityOutputManager::OnHookRemoved()
{
	HookCount--;

	if (HookCount == 0)
	{
		//we need to check if we are inside a detour. easy.
		//if we are how do we 
		ShutdownFireEventDetour();
	}
}

void EntityOutputManager::CleanUpHook(omg_hooks *hook)
{
	FreeHooks.push(hook);

	OnHookRemoved();

	IPlugin *pPlugin = plsys->FindPluginByContext(hook->pf->GetParentContext()->GetContext());
	SourceHook::List<omg_hooks *> *pList = NULL;

	if (!pPlugin->GetProperty("OutputHookList", (void **)&pList, false) || !pList)
	{
		return;
	}

	SourceHook::List<omg_hooks *>::iterator p_iter = pList->begin();

	omg_hooks *pluginHook;

	while (p_iter != pList->end())
	{
		pluginHook = (omg_hooks *)*p_iter;
		if (pluginHook == hook)
		{
			p_iter = pList->erase(p_iter);
		}
		else
		{
			p_iter++;
		}
	}
}

void EntityOutputManager::OnPluginDestroyed(IPlugin *plugin)
{
	SourceHook::List<omg_hooks *> *pList = NULL;

	if (plugin->GetProperty("OutputHookList", (void **)&pList, true))
	{
		SourceHook::List<omg_hooks *>::iterator p_iter = pList->begin();
		omg_hooks *hook;

		while (p_iter != pList->end())
		{
			hook = (omg_hooks *)*p_iter;
		
			p_iter = pList->erase(p_iter); //remove from this plugins list
			hook->m_parent->hooks.remove(hook); // remove from the y's list

			FreeHooks.push(hook); //save the omg_hook

			OnHookRemoved();
		}		
	}
}

OutputNameStruct *EntityOutputManager::FindOutputPointer(const char *classname, const char *outputname, bool create)
{
	ClassNameStruct *pClassname;
	
	if (!ClassNames->Retrieve(classname, (void **)&pClassname))
	{
		if (create)
		{
			pClassname = new ClassNameStruct;
			ClassNames->Insert(classname, pClassname);
		}
		else
		{
			return NULL;
		}
	}

	OutputNameStruct *pOutputName;

	if (!pClassname->OutputList->Retrieve(outputname, (void **)&pOutputName))
	{
		if (create)
		{
			pOutputName = new OutputNameStruct;
			pClassname->OutputList->Insert(outputname, pOutputName);
			strncpy(pOutputName->Name, outputname, sizeof(pOutputName->Name));
			pOutputName->Name[49] = 0;
		}
		else
		{
			return NULL;
		}
	}

	return pOutputName;
}

// Iterate the datamap of pCaller and look for output pointers with the same address as pOutput
const char *EntityOutputManager::FindOutputName(void *pOutput, CBaseEntity *pCaller)
{
	datamap_t *pMap = gamehelpers->GetDataMap(pCaller);

	while (pMap)
	{
		for (int i=0; i<pMap->dataNumFields; i++)
		{
			if (pMap->dataDesc[i].flags & FTYPEDESC_OUTPUT)
			{
				if ((char *)pCaller + pMap->dataDesc[i].fieldOffset[0] == pOutput)
				{
					return pMap->dataDesc[i].externalName;
				}
			}
		}
		pMap = pMap->baseMap;
	}

	return NULL;
}
#if 0
// Almost identical copy of this function from cbase.cpp - FIELD_EHANDLE changed to remove dependencies
const char *variant_t::ToString( void ) const
{
	COMPILE_TIME_ASSERT( sizeof(string_t) == sizeof(int) );

	static char szBuf[512];

	switch (fieldType)
	{
	case FIELD_STRING:
		{
			return(STRING(iszVal));
		}

	case FIELD_BOOLEAN:
		{
			if (bVal == 0)
			{
				Q_strncpy(szBuf, "false",sizeof(szBuf));
			}
			else
			{
				Q_strncpy(szBuf, "true",sizeof(szBuf));
			}
			return(szBuf);
		}

	case FIELD_INTEGER:
		{
			Q_snprintf( szBuf, sizeof( szBuf ), "%i", iVal );
			return(szBuf);
		}

	case FIELD_FLOAT:
		{
			Q_snprintf(szBuf,sizeof(szBuf), "%g", flVal);
			return(szBuf);
		}

	case FIELD_COLOR32:
		{
			Q_snprintf(szBuf,sizeof(szBuf), "%d %d %d %d", (int)rgbaVal.r, (int)rgbaVal.g, (int)rgbaVal.b, (int)rgbaVal.a);
			return(szBuf);
		}

	case FIELD_VECTOR:
		{
			Q_snprintf(szBuf,sizeof(szBuf), "[%g %g %g]", (double)vecVal[0], (double)vecVal[1], (double)vecVal[2]);
			return(szBuf);
		}

	case FIELD_VOID:
		{
			szBuf[0] = '\0';
			return(szBuf);
		}

	case FIELD_EHANDLE:
		{
			CBaseHandle temp = eVal;

			const char *pszName = g_OutputManager.BaseHandleToEdict(temp)->GetClassName();

			if (pszName == NULL)
			{
				Q_strncpy( szBuf, "<<null entity>>", 512 );
				return (szBuf);
			}

			Q_strncpy( szBuf, pszName, 512 );
			return (szBuf);
		}

	default:
		break;
	}

	return("No conversion to string");
}
#endif
// Thanks SM core
edict_t *EntityOutputManager::BaseHandleToEdict(CBaseHandle &hndl)
{
	if (!hndl.IsValid())
	{
		return NULL;
	}

	int index = hndl.GetEntryIndex();

	edict_t *pStoredEdict;

	pStoredEdict = engine->PEntityOfEntIndex(index);

	if (pStoredEdict == NULL)
	{
		return NULL;
	}

	IServerEntity *pSE = pStoredEdict->GetIServerEntity();

	if (pSE == NULL)
	{
		return NULL;
	}

	if (pSE->GetRefEHandle() != hndl)
	{
		return NULL;
	}

	return pStoredEdict;
}