#include <sourcemod>
#include <sdkhooks>
#include <sdktools>
#include <CSSFixes>
#include <dhooks>

#define SetBit(%1,%2)		((%1)[(%2) >> 5] |= (1 << ((%2) & 31)))
#define ClearBit(%1,%2)		((%1)[(%2) >> 5] &= ~(1 << ((%2) & 31)))
#define CheckBit(%1,%2)		!!((%1)[(%2) >> 5] & (1 << ((%2) & 31)))

#pragma semicolon 1
#pragma newdecls required

public Plugin myinfo =
{
	name 			= "LagCompensation",
	author 			= "BotoX",
	description 	= "",
	version 		= "1.0",
	url 			= ""
};

bool g_bLateLoad = false;
bool g_bHasCSSFixes = true;

// Don't change this.
#define MAX_EDICTS 2048
#define FSOLID_FORCE_WORLD_ALIGNED 0x0040
#define FSOLID_ROOT_PARENT_ALIGNED 0x0100
#define EFL_DIRTY_ABSTRANSFORM (1<<11)
#define EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS (1<<14)
#define EFL_CHECK_UNTOUCH (1<<24)
#define COORDINATE_FRAME_SIZE 14

enum
{
	USE_OBB_COLLISION_BOUNDS = 0,
	USE_BEST_COLLISION_BOUNDS,
	USE_HITBOXES,
	USE_SPECIFIED_BOUNDS,
	USE_GAME_CODE,
	USE_ROTATION_EXPANDED_BOUNDS,
	USE_COLLISION_BOUNDS_NEVER_VPHYSICS,
}

enum
{
	SOLID_NONE			= 0,	// no solid model
	SOLID_BSP			= 1,	// a BSP tree
	SOLID_BBOX			= 2,	// an AABB
	SOLID_OBB			= 3,	// an OBB (not implemented yet)
	SOLID_OBB_YAW		= 4,	// an OBB, constrained so that it can only yaw
	SOLID_CUSTOM		= 5,	// Always call into the entity for tests
	SOLID_VPHYSICS		= 6,	// solid vphysics object, get vcollide from the model and collide with that
	SOLID_LAST,
};

enum
{
	SF_TRIGGER_ALLOW_CLIENTS				= 0x01,		// Players can fire this trigger
	SF_TRIGGER_ALLOW_NPCS					= 0x02,		// NPCS can fire this trigger
	SF_TRIGGER_ALLOW_PUSHABLES				= 0x04,		// Pushables can fire this trigger
	SF_TRIGGER_ALLOW_PHYSICS				= 0x08,		// Physics objects can fire this trigger
	SF_TRIGGER_ONLY_PLAYER_ALLY_NPCS		= 0x10,		// *if* NPCs can fire this trigger, this flag means only player allies do so
	SF_TRIGGER_ONLY_CLIENTS_IN_VEHICLES		= 0x20,		// *if* Players can fire this trigger, this flag means only players inside vehicles can
	SF_TRIGGER_ALLOW_ALL					= 0x40,		// Everything can fire this trigger EXCEPT DEBRIS!
	SF_TRIGGER_ONLY_CLIENTS_OUT_OF_VEHICLES	= 0x200,	// *if* Players can fire this trigger, this flag means only players outside vehicles can
	SF_TRIG_PUSH_ONCE						= 0x80,		// trigger_push removes itself after firing once
	SF_TRIG_PUSH_AFFECT_PLAYER_ON_LADDER	= 0x100,	// if pushed object is player on a ladder, then this disengages them from the ladder (HL2only)
	SF_TRIG_TOUCH_DEBRIS 					= 0x400,	// Will touch physics debris objects
	SF_TRIGGER_ONLY_NPCS_IN_VEHICLES		= 0x800,	// *if* NPCs can fire this trigger, only NPCs in vehicles do so (respects player ally flag too)
};

#define SF_LAGCOMP_DISABLE (1 << 30)

#define MAX_RECORDS 32
#define MAX_ENTITIES 256
//#define DEBUG

enum struct LagRecord
{
	float vecOrigin[3];
	float vecAbsOrigin[3];
	float angRotation[3];
	float angAbsRotation[3];
	float flSimulationTime;
	float rgflCoordinateFrame[COORDINATE_FRAME_SIZE];
}

enum struct EntityLagData
{
	int iEntity;
	int iRecordIndex;
	int iNumRecords;
	int iRecordsValid;
	int iSpawned;
	int iDeleted;
	int iNotMoving;
	int iTouchStamp;
	bool bRestore;
	bool bLateKill;
	LagRecord RestoreData;
}

LagRecord g_aaLagRecords[MAX_ENTITIES][MAX_RECORDS];
EntityLagData g_aEntityLagData[MAX_ENTITIES];
int g_iNumEntities = 0;
bool g_bCleaningUp = true;

Handle g_hCalcAbsolutePosition;
Handle g_hMarkPartitionHandleDirty;

Handle g_hUTIL_Remove;
Handle g_hRestartRound;
Handle g_hSetTarget;
Handle g_hSetTargetPost;
Handle g_hFrameUpdatePostEntityThink;
Handle g_hActivate;
Handle g_hAcceptInput;

int g_iParent;
int g_iSpawnFlags;
int g_iTouchStamp;
int g_iCollision;
int g_iSolidFlags;
int g_iSolidType;
int g_iSurroundType;
int g_iEFlags;
int g_iVecOrigin;
int g_iVecAbsOrigin;
int g_iAngRotation;
int g_iAngAbsRotation;
int g_iSimulationTime;
int g_iCoordinateFrame;

int g_aLagCompensated[MAX_EDICTS] = {-1, ...};
int g_aFilterTriggerTouch[MAX_EDICTS / 32];
int g_aaFilterClientEntity[((MAXPLAYERS + 1) * MAX_EDICTS) / 32];
int g_aBlockTriggerMoved[MAX_EDICTS / 32];
int g_aBlacklisted[MAX_EDICTS / 32];

public void OnPluginStart()
{
	Handle hGameData = LoadGameConfigFile("LagCompensation.games");
	if(!hGameData)
		SetFailState("Failed to load LagCompensation gamedata.");

	// CBaseEntity::CalcAbsolutePosition
	StartPrepSDKCall(SDKCall_Entity);
	if(!PrepSDKCall_SetFromConf(hGameData, SDKConf_Signature, "CalcAbsolutePosition"))
	{
		delete hGameData;
		SetFailState("PrepSDKCall_SetFromConf(hGameData, SDKConf_Signature, \"CalcAbsolutePosition\") failed!");
	}
	g_hCalcAbsolutePosition = EndPrepSDKCall();

	// CCollisionProperty::MarkPartitionHandleDirty
	StartPrepSDKCall(SDKCall_Raw);
	if(!PrepSDKCall_SetFromConf(hGameData, SDKConf_Signature, "MarkPartitionHandleDirty"))
	{
		delete hGameData;
		SetFailState("PrepSDKCall_SetFromConf(hGameData, SDKConf_Signature, \"MarkPartitionHandleDirty\") failed!");
	}
	g_hMarkPartitionHandleDirty = EndPrepSDKCall();


	// ::UTIL_Remove
	g_hUTIL_Remove = DHookCreateFromConf(hGameData, "UTIL_Remove");
	if(!g_hUTIL_Remove)
	{
		delete hGameData;
		SetFailState("Failed to setup detour for UTIL_Remove");
	}

	if(!DHookEnableDetour(g_hUTIL_Remove, false, Detour_OnUTIL_Remove))
	{
		delete hGameData;
		SetFailState("Failed to detour UTIL_Remove.");
	}

	// CCSGameRules::RestartRound
	g_hRestartRound = DHookCreateFromConf(hGameData, "CCSGameRules__RestartRound");
	if(!g_hRestartRound)
	{
		delete hGameData;
		SetFailState("Failed to setup detour for CCSGameRules__RestartRound");
	}

	if(!DHookEnableDetour(g_hRestartRound, false, Detour_OnRestartRound))
	{
		delete hGameData;
		SetFailState("Failed to detour CCSGameRules__RestartRound.");
	}

	// CLogicMeasureMovement::SetTarget
	g_hSetTarget = DHookCreateFromConf(hGameData, "CLogicMeasureMovement__SetTarget");
	if(!g_hSetTarget)
	{
		delete hGameData;
		SetFailState("Failed to setup detour for CLogicMeasureMovement__SetTarget");
	}

	if(!DHookEnableDetour(g_hSetTarget, false, Detour_OnSetTargetPre))
	{
		delete hGameData;
		SetFailState("Failed to detour CLogicMeasureMovement__SetTarget.");
	}

	// CLogicMeasureMovement::SetTarget (fix post hook crashing due to this pointer being overwritten)
	g_hSetTargetPost = DHookCreateFromConf(hGameData, "CLogicMeasureMovement__SetTarget_post");
	if(!g_hSetTargetPost)
	{
		delete hGameData;
		SetFailState("Failed to setup detour for CLogicMeasureMovement__SetTarget_post");
	}

	if(!DHookEnableDetour(g_hSetTargetPost, true, Detour_OnSetTargetPost))
	{
		delete hGameData;
		SetFailState("Failed to detour CLogicMeasureMovement__SetTarget_post.");
	}

	// CEntityTouchManager::FrameUpdatePostEntityThink
	g_hFrameUpdatePostEntityThink = DHookCreateFromConf(hGameData, "CEntityTouchManager__FrameUpdatePostEntityThink");
	if(!g_hFrameUpdatePostEntityThink)
	{
		delete hGameData;
		SetFailState("Failed to setup detour for CEntityTouchManager__FrameUpdatePostEntityThink");
	}

	if(!DHookEnableDetour(g_hFrameUpdatePostEntityThink, false, Detour_OnFrameUpdatePostEntityThink))
	{
		delete hGameData;
		SetFailState("Failed to detour CEntityTouchManager__FrameUpdatePostEntityThink.");
	}

	delete hGameData;


	hGameData = LoadGameConfigFile("sdktools.games");
	if(!hGameData)
		SetFailState("Failed to load sdktools gamedata.");

	int offset = GameConfGetOffset(hGameData, "Activate");
	if(offset == -1)
		SetFailState("Failed to find Activate offset");

	// CPhysForce::Activate
	g_hActivate = DHookCreate(offset, HookType_Entity, ReturnType_Void, ThisPointer_CBaseEntity, Hook_CPhysForce_Activate);
	if(g_hActivate == INVALID_HANDLE)
		SetFailState("Failed to DHookCreate Activate");

	offset = GameConfGetOffset(hGameData, "AcceptInput");
	if(offset == -1)
		SetFailState("Failed to find AcceptInput offset.");

	// CBaseEntity::AcceptInput( const char *szInputName, CBaseEntity *pActivator, CBaseEntity *pCaller, variant_t Value, int outputID )
	g_hAcceptInput = DHookCreate(offset, HookType_Entity, ReturnType_Bool, ThisPointer_CBaseEntity, OnAcceptInput);
	if(g_hAcceptInput == INVALID_HANDLE)
		SetFailState("Failed to DHook AcceptInput.");

	DHookAddParam(g_hAcceptInput, HookParamType_CharPtr);
	DHookAddParam(g_hAcceptInput, HookParamType_CBaseEntity);
	DHookAddParam(g_hAcceptInput, HookParamType_CBaseEntity);
	DHookAddParam(g_hAcceptInput, HookParamType_Object, 20, DHookPass_ByVal|DHookPass_ODTOR|DHookPass_OCTOR|DHookPass_OASSIGNOP); // variant_t is a union of 12 (float[3]) plus two int type params 12 + 8 = 20
	DHookAddParam(g_hAcceptInput, HookParamType_Int);

	delete hGameData;


	RegAdminCmd("sm_unlag", Command_AddLagCompensation, ADMFLAG_RCON, "sm_unlag <entidx>");
	RegAdminCmd("sm_lagged", Command_CheckLagCompensated, ADMFLAG_GENERIC, "sm_lagged");

	FilterClientEntityMap(g_aaFilterClientEntity, true);
	BlockTriggerMoved(g_aBlockTriggerMoved, true);
}

public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max)
{
	g_bLateLoad = late;
	return APLRes_Success;
}

public void OnLibraryRemoved(const char[] name)
{
	if(StrEqual(name, "CSSFixes"))
		g_bHasCSSFixes = false;
}

public void OnPluginEnd()
{
	g_bCleaningUp = true;
	if(g_bHasCSSFixes)
	{
		FilterClientEntityMap(g_aaFilterClientEntity, false);
		BlockTriggerMoved(g_aBlockTriggerMoved, false);
		FilterTriggerTouchPlayers(g_aFilterTriggerTouch, false);
	}

	DHookDisableDetour(g_hUTIL_Remove, false, Detour_OnUTIL_Remove);

	for(int i = 0; i < g_iNumEntities; i++)
	{
		if(!IsValidEntity(g_aEntityLagData[i].iEntity))
			continue;

		if(g_aEntityLagData[i].iDeleted)
		{
			RemoveEdict(g_aEntityLagData[i].iEntity);
		}
	}
}

public void OnMapStart()
{
	bool bLate = g_bLateLoad;

	g_bCleaningUp = false;

	g_iParent = FindDataMapInfo(0, "m_pParent");
	g_iSpawnFlags = FindDataMapInfo(0, "m_spawnflags");
	g_iTouchStamp = FindDataMapInfo(0, "touchStamp");
	g_iCollision = FindDataMapInfo(0, "m_Collision");
	g_iSolidFlags = FindDataMapInfo(0, "m_usSolidFlags");
	g_iSolidType = FindDataMapInfo(0, "m_nSolidType");
	g_iSurroundType = FindDataMapInfo(0, "m_nSurroundType");
	g_iEFlags = FindDataMapInfo(0, "m_iEFlags");

	g_iVecOrigin = FindDataMapInfo(0, "m_vecOrigin");
	g_iVecAbsOrigin = FindDataMapInfo(0, "m_vecAbsOrigin");
	g_iAngRotation = FindDataMapInfo(0, "m_angRotation");
	g_iAngAbsRotation = FindDataMapInfo(0, "m_angAbsRotation");
	g_iSimulationTime = FindDataMapInfo(0, "m_flSimulationTime");
	g_iCoordinateFrame = FindDataMapInfo(0, "m_rgflCoordinateFrame");

	/* Late Load */
	if(bLate)
	{
		int entity = INVALID_ENT_REFERENCE;
		while((entity = FindEntityByClassname(entity, "*")) != INVALID_ENT_REFERENCE)
		{
			char sClassname[64];
			if(GetEntityClassname(entity, sClassname, sizeof(sClassname)))
			{
				OnEntityCreated(entity, sClassname);
				OnEntitySpawned(entity, sClassname);

				if(StrEqual(sClassname, "phys_thruster", false))
				{
					Hook_CPhysForce_Activate(entity);
				}
			}
		}
	}

	g_bLateLoad = false;
}

public void OnEntityCreated(int entity, const char[] classname)
{
	if(g_bCleaningUp)
		return;

	if(StrEqual(classname, "phys_thruster", false))
	{
		DHookEntity(g_hActivate, true, entity);
	}
	else if(StrEqual(classname, "game_ui", false))
	{
		DHookEntity(g_hAcceptInput, true, entity);
	}
}

public void OnEntitySpawned(int entity, const char[] classname)
{
	if(g_bCleaningUp)
		return;

	CheckEntityForLagComp(entity, classname);
}

public MRESReturn OnAcceptInput(int entity, Handle hReturn, Handle hParams)
{
	if(!IsValidEntity(entity))
		return MRES_Ignored;

	char sCommand[128];
	DHookGetParamString(hParams, 1, sCommand, sizeof(sCommand));

	if(!StrEqual(sCommand, "Activate", false))
		return MRES_Ignored;

	if(DHookIsNullParam(hParams, 3))
		return MRES_Ignored;

	int iCaller = DHookGetParam(hParams, 3);
	if(iCaller <= 0 || iCaller >= MAX_EDICTS)
		return MRES_Ignored;

	// Don't lagcompensate anything that has a game_ui button in their hierarchy.
	BlacklistFamily(iCaller);

	return MRES_Ignored;
}

void BlacklistFamily(int entity)
{
	if(entity > 0 && entity < MAX_EDICTS)
	{
		SetBit(g_aBlacklisted, entity);
		RemoveEntityFromLagCompensation(entity);
	}

	// Blacklist children of this entity
	BlacklistChildren(entity);

	// And blacklist all parents and their children
	for(;;)
	{
		entity = GetEntDataEnt2(entity, g_iParent);
		if(entity == INVALID_ENT_REFERENCE)
			break;

		if(entity > 0 && entity < MAX_EDICTS)
		{
			SetBit(g_aBlacklisted, entity);
			RemoveEntityFromLagCompensation(entity);
		}

		// And their children
		BlacklistChildren(entity);
	}
}

void BlacklistChildren(int parent)
{
	int entity = INVALID_ENT_REFERENCE;
	while((entity = FindEntityByClassname(entity, "*")) != INVALID_ENT_REFERENCE)
	{
		if(GetEntDataEnt2(entity, g_iParent) != parent)
			continue;

		if(entity > 0 && entity < MAX_EDICTS)
		{
			SetBit(g_aBlacklisted, entity);
			RemoveEntityFromLagCompensation(entity);
		}
	}
}

bool CheckEntityForLagComp(int entity, const char[] classname, bool bRecursive=false, bool bGoodParents=false)
{
	if(entity < 0 || entity > MAX_EDICTS)
		return false;

	if(!IsValidEntity(entity))
		return false;

	if(g_aLagCompensated[entity] != -1)
		return false;

	int SpawnFlags = GetEntData(entity, g_iSpawnFlags);
	if(SpawnFlags & SF_LAGCOMP_DISABLE)
		return false;

	bool bTrigger = StrEqual(classname, "trigger_hurt", false) ||
					StrEqual(classname, "trigger_push", false) ||
					StrEqual(classname, "trigger_teleport", false);

	bool bPhysbox = !strncmp(classname, "func_physbox", 12, false);

	bool bBlacklisted = CheckBit(g_aBlacklisted, entity);

	if(!bTrigger && !bPhysbox || bBlacklisted)
		return false;

	// Don't lag compensate anything that could be parented to a player
	// The player simulation would usually move the entity,
	// but we would overwrite that position change by restoring the entity to its previous state.
	int iParent = INVALID_ENT_REFERENCE;
	char sParentClassname[64];
	for(int iTmp = entity;;)
	{
		iTmp = GetEntDataEnt2(iTmp, g_iParent);
		if(iTmp == INVALID_ENT_REFERENCE)
			break;

		iParent = iTmp;
		GetEntityClassname(iParent, sParentClassname, sizeof(sParentClassname));

		if(StrEqual(sParentClassname, "player") ||
			!strncmp(sParentClassname, "weapon_", 7))
		{
			return false;
		}

		if(CheckBit(g_aBlacklisted, entity))
		{
			return false;
		}

		if(g_aLagCompensated[iParent] != -1)
		{
			bGoodParents = true;
			break;
		}

		if(strncmp(sParentClassname, "func_", 5))
			continue;

		if(StrEqual(sParentClassname[5], "movelinear") ||
			StrEqual(sParentClassname[5], "door") ||
			StrEqual(sParentClassname[5], "rotating") ||
			StrEqual(sParentClassname[5], "tracktrain"))
		{
			bGoodParents = true;
			break;
		}
	}

	if(!bGoodParents)
		return false;

	if(AddEntityForLagCompensation(entity, bTrigger))
	{
		if(bTrigger)
		{
			if(!(SpawnFlags & (SF_TRIGGER_ALLOW_PUSHABLES | SF_TRIGGER_ALLOW_PHYSICS | SF_TRIGGER_ALLOW_ALL | SF_TRIG_TOUCH_DEBRIS)))
				SetBit(g_aBlockTriggerMoved, entity);
		}

		if(bRecursive)
		{
			CheckEntityChildrenForLagComp(entity);
		}

		return true;
	}

	return false;
}

void CheckEntityChildrenForLagComp(int parent)
{
	int entity = INVALID_ENT_REFERENCE;
	while((entity = FindEntityByClassname(entity, "*")) != INVALID_ENT_REFERENCE)
	{
		if(GetEntDataEnt2(entity, g_iParent) != parent)
			continue;

		char sClassname[64];
		if(GetEntityClassname(entity, sClassname, sizeof(sClassname)))
		{
			CheckEntityForLagComp(entity, sClassname, _, true);
			CheckEntityChildrenForLagComp(entity);
		}
	}
}

public void OnEntityDestroyed(int entity)
{
	if(g_bCleaningUp)
		return;

	if(entity < 0 || entity > MAX_EDICTS)
		return;

	ClearBit(g_aBlacklisted, entity);

	int iIndex = g_aLagCompensated[entity];
	if(iIndex == -1)
		return;

	RemoveRecord(iIndex);
}


public MRESReturn Detour_OnUTIL_Remove(Handle hParams)
{
	if(g_bCleaningUp)
		return MRES_Ignored;

	int entity = DHookGetParam(hParams, 1);
	if(entity < 0 || entity > MAX_EDICTS)
		return MRES_Ignored;

	int iIndex = g_aLagCompensated[entity];
	if(iIndex == -1)
		return MRES_Ignored;

	// let it die
	if(!g_aEntityLagData[iIndex].bLateKill)
		return MRES_Ignored;

	// ignore sleeping entities
	if(g_aEntityLagData[iIndex].iNotMoving >= MAX_RECORDS)
		return MRES_Ignored;

	if(!g_aEntityLagData[iIndex].iDeleted)
	{
		g_aEntityLagData[iIndex].iDeleted = GetGameTickCount();
	}

	return MRES_Supercede;
}

public MRESReturn Detour_OnRestartRound()
{
	g_bCleaningUp = true;

	for(int i = 0; i < g_iNumEntities; i++)
	{
		int iEntity = g_aEntityLagData[i].iEntity;

		g_aLagCompensated[iEntity] = -1;
		ClearBit(g_aFilterTriggerTouch, iEntity);
		ClearBit(g_aBlockTriggerMoved, iEntity);

		for(int client = 1; client <= MaxClients; client++)
		{
			ClearBit(g_aaFilterClientEntity, client * MAX_EDICTS + iEntity);
		}

		if(g_aEntityLagData[i].iDeleted)
		{
			if(IsValidEntity(iEntity))
				RemoveEdict(iEntity);
		}

		g_aEntityLagData[i].iEntity = INVALID_ENT_REFERENCE;
	}

	for(int i = 0; i < sizeof(g_aBlacklisted); i++)
		g_aBlacklisted[i] = 0;

	g_iNumEntities = 0;

	g_bCleaningUp = false;
	return MRES_Ignored;
}

// https://developer.valvesoftware.com/wiki/Logic_measure_movement
int g_OnSetTarget_pThis;
public MRESReturn Detour_OnSetTargetPre(int pThis, Handle hParams)
{
	g_OnSetTarget_pThis = pThis;
	return MRES_Ignored;
}
public MRESReturn Detour_OnSetTargetPost(Handle hParams)
{
	int entity = GetEntPropEnt(g_OnSetTarget_pThis, Prop_Data, "m_hTarget");
	if(!IsValidEntity(entity))
		return MRES_Ignored;

	char sClassname[64];
	if(!GetEntityClassname(entity, sClassname, sizeof(sClassname)))
		return MRES_Ignored;

	CheckEntityForLagComp(entity, sClassname, true, true);

	return MRES_Ignored;
}

public MRESReturn Hook_CPhysForce_Activate(int entity)
{
	int attachedObject = GetEntPropEnt(entity, Prop_Data, "m_attachedObject");
	if(!IsValidEntity(attachedObject))
		return MRES_Ignored;

	char sClassname[64];
	if(!GetEntityClassname(attachedObject, sClassname, sizeof(sClassname)))
		return MRES_Ignored;

	CheckEntityForLagComp(attachedObject, sClassname, true, true);

	return MRES_Ignored;
}

public MRESReturn Detour_OnFrameUpdatePostEntityThink()
{
	for(int i = 0; i < g_iNumEntities; i++)
	{
		// Don't make the entity check untouch in FrameUpdatePostEntityThink.
		// If the player didn't get simulated in the current frame then
		// they didn't have a chance to touch this entity.
		// Hence the touchlink could be broken and we only let the player check untouch.
		int EFlags = GetEntData(g_aEntityLagData[i].iEntity, g_iEFlags);
		EFlags &= ~EFL_CHECK_UNTOUCH;
		SetEntData(g_aEntityLagData[i].iEntity, g_iEFlags, EFlags);
	}
}


public void OnRunThinkFunctions(bool simulating)
{
	FilterTriggerTouchPlayers(g_aFilterTriggerTouch, false);

	for(int i = 0; i < g_iNumEntities; i++)
	{
		if(!IsValidEntity(g_aEntityLagData[i].iEntity))
		{
			PrintToBoth("!!!!!!!!!!! OnRunThinkFunctions SHIT deleted: %d / %d", i, g_aEntityLagData[i].iEntity);
			RemoveRecord(i);
			i--; continue;
		}

		// Save old touchStamp
		int touchStamp = GetEntData(g_aEntityLagData[i].iEntity, g_iTouchStamp);
		g_aEntityLagData[i].iTouchStamp = touchStamp;
		// We have to increase the touchStamp by 1 here to avoid breaking the touchlink.
		// The touchStamp is incremented by 1 every time an entities physics are simulated.
		// When two entities touch then a touchlink is created on both entities with the touchStamp of either entity.
		// Usually the player would touch the trigger first and then the trigger would touch the player later on in the same frame.
		// The trigger touching the player would fix up the touchStamp (which was increased by 1 by the trigger physics simulate)
		// But since we're blocking the trigger from ever touching a player outside of here we need to manually increase it by 1 up front
		// so the correct +1'd touchStamp is stored in the touchlink.
		// After simulating the players we restore the old touchStamp (-1) and when the entity is simulated it will increase it again by 1
		// Thus both touchlinks will have the correct touchStamp value.
		// The touchStamp doesn't increase when the entity is idle, however it also doesn't check untouch so we're fine.
		touchStamp++;
		SetEntData(g_aEntityLagData[i].iEntity, g_iTouchStamp, touchStamp);

		if(g_aEntityLagData[i].iDeleted)
		{
			if(g_aEntityLagData[i].iDeleted + MAX_RECORDS <= GetGameTickCount())
			{
				// calls OnEntityDestroyed right away
				// which calls RemoveRecord
				// which moves the next element to our current position
				RemoveEdict(g_aEntityLagData[i].iEntity);
				i--; continue;
			}
			continue;
		}

		if(g_aEntityLagData[i].iNotMoving >= MAX_RECORDS)
			continue;

		RecordDataIntoRecord(g_aEntityLagData[i].iEntity, g_aEntityLagData[i].RestoreData);
	}
}

public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2])
{
	if(!IsPlayerAlive(client))
		return Plugin_Continue;

	// -1 because the newest record in the list is one tick old
	// this is because we simulate players first
	// hence no new entity record was inserted on the current tick
	int iGameTick = GetGameTickCount() - 1;

	int iDelta = iGameTick - tickcount;
	if(iDelta < 0)
		iDelta = 0;

	if(iDelta > MAX_RECORDS)
		iDelta = MAX_RECORDS;

	int iPlayerSimTick = iGameTick - iDelta;

	for(int i = 0; i < g_iNumEntities; i++)
	{
		int iEntity = g_aEntityLagData[i].iEntity;

		// Entity too new, the client couldn't even see it yet.
		if(g_aEntityLagData[i].iSpawned > iPlayerSimTick)
		{
			SetBit(g_aaFilterClientEntity, client * MAX_EDICTS + iEntity);
			continue;
		}
		else if(g_aEntityLagData[i].iSpawned == iPlayerSimTick)
		{
			ClearBit(g_aaFilterClientEntity, client * MAX_EDICTS + iEntity);
		}

		if(g_aEntityLagData[i].iDeleted)
		{
			if(g_aEntityLagData[i].iDeleted <= iPlayerSimTick)
			{
				SetBit(g_aaFilterClientEntity, client * MAX_EDICTS + iEntity);
				continue;
			}
		}

		if(g_aEntityLagData[i].iNotMoving >= MAX_RECORDS)
			continue;

		int iRecord = iDelta;
		if(iRecord >= g_aEntityLagData[i].iNumRecords)
			iRecord = g_aEntityLagData[i].iNumRecords - 1;

		int iRecordIndex = g_aEntityLagData[i].iRecordIndex - iRecord;
		if(iRecordIndex < 0)
			iRecordIndex += MAX_RECORDS;

		RestoreEntityFromRecord(iEntity, g_aaLagRecords[i][iRecordIndex]);
		g_aEntityLagData[i].bRestore = !g_aEntityLagData[i].iDeleted;
	}

	return Plugin_Continue;
}

public void OnPostPlayerThinkFunctions()
{
	for(int i = 0; i < g_iNumEntities; i++)
	{
		// Restore original touchStamp
		SetEntData(g_aEntityLagData[i].iEntity, g_iTouchStamp, g_aEntityLagData[i].iTouchStamp);

		if(!g_aEntityLagData[i].bRestore)
			continue;

		RestoreEntityFromRecord(g_aEntityLagData[i].iEntity, g_aEntityLagData[i].RestoreData);
		g_aEntityLagData[i].bRestore = false;
	}

	FilterTriggerTouchPlayers(g_aFilterTriggerTouch, true);
}

public void OnRunThinkFunctionsPost(bool simulating)
{
	for(int i = 0; i < g_iNumEntities; i++)
	{
		if(g_aEntityLagData[i].iDeleted)
		{
			if(g_aEntityLagData[i].iRecordsValid)
			{
				g_aEntityLagData[i].iRecordIndex++;

				if(g_aEntityLagData[i].iRecordIndex >= MAX_RECORDS)
					g_aEntityLagData[i].iRecordIndex = 0;

				g_aEntityLagData[i].iRecordsValid--;
			}

			continue;
		}

		LagRecord TmpRecord;
		RecordDataIntoRecord(g_aEntityLagData[i].iEntity, TmpRecord);

		// sleep detection
		{
			int iOldRecord = g_aEntityLagData[i].iRecordIndex;

			if(CompareVectors(g_aaLagRecords[i][iOldRecord].vecAbsOrigin, TmpRecord.vecAbsOrigin) &&
				CompareVectors(g_aaLagRecords[i][iOldRecord].angAbsRotation, TmpRecord.angAbsRotation))
			{
				g_aEntityLagData[i].iNotMoving++;
			}
			else
			{
				g_aEntityLagData[i].iNotMoving = 0;
			}

			if(g_aEntityLagData[i].iNotMoving >= MAX_RECORDS)
				continue;
		}

		g_aEntityLagData[i].iRecordIndex++;

		if(g_aEntityLagData[i].iRecordIndex >= MAX_RECORDS)
			g_aEntityLagData[i].iRecordIndex = 0;

		if(g_aEntityLagData[i].iNumRecords < MAX_RECORDS)
			g_aEntityLagData[i].iRecordsValid = ++g_aEntityLagData[i].iNumRecords;

		LagRecord_Copy(g_aaLagRecords[i][g_aEntityLagData[i].iRecordIndex], TmpRecord);
	}
}


void RecordDataIntoRecord(int iEntity, LagRecord Record)
{
	// Force recalculation of all values
	int EFlags = GetEntData(iEntity, g_iEFlags);
	EFlags |= EFL_DIRTY_ABSTRANSFORM;
	SetEntData(iEntity, g_iEFlags, EFlags);

	SDKCall(g_hCalcAbsolutePosition, iEntity);

	GetEntDataVector(iEntity, g_iVecOrigin, Record.vecOrigin);
	GetEntDataVector(iEntity, g_iVecAbsOrigin, Record.vecAbsOrigin);
	GetEntDataVector(iEntity, g_iAngRotation, Record.angRotation);
	GetEntDataVector(iEntity, g_iAngAbsRotation, Record.angAbsRotation);
	GetEntDataArray(iEntity, g_iCoordinateFrame, view_as<int>(Record.rgflCoordinateFrame), COORDINATE_FRAME_SIZE);
	Record.flSimulationTime = GetEntDataFloat(iEntity, g_iSimulationTime);
}

bool DoesRotationInvalidateSurroundingBox(int iEntity)
{
	int SolidFlags = GetEntData(iEntity, g_iSolidFlags);
	if(SolidFlags & FSOLID_ROOT_PARENT_ALIGNED)
		return true;

	int SurroundType = GetEntData(iEntity, g_iSurroundType);
	switch(SurroundType)
	{
		case USE_COLLISION_BOUNDS_NEVER_VPHYSICS,
			 USE_OBB_COLLISION_BOUNDS,
			 USE_BEST_COLLISION_BOUNDS:
		{
			// IsBoundsDefinedInEntitySpace()
			int SolidType = GetEntData(iEntity, g_iSolidType);
			return ((SolidFlags & FSOLID_FORCE_WORLD_ALIGNED) == 0) &&
					(SolidType != SOLID_BBOX) && (SolidType != SOLID_NONE);
		}

		case USE_HITBOXES,
			 USE_GAME_CODE:
		{
			return true;
		}

		case USE_ROTATION_EXPANDED_BOUNDS,
			 USE_SPECIFIED_BOUNDS:
		{
			return false;
		}

		default:
		{
			return true;
		}
	}
}

void InvalidatePhysicsRecursive(int iEntity)
{
	// NetworkProp()->MarkPVSInformationDirty()
	int fStateFlags = GetEdictFlags(iEntity);
	fStateFlags |= FL_EDICT_DIRTY_PVS_INFORMATION;
	SetEdictFlags(iEntity, fStateFlags);

	// CollisionProp()->MarkPartitionHandleDirty();
	Address CollisionProp = GetEntityAddress(iEntity) + view_as<Address>(g_iCollision);
	SDKCall(g_hMarkPartitionHandleDirty, CollisionProp);

	if(DoesRotationInvalidateSurroundingBox(iEntity))
	{
		// CollisionProp()->MarkSurroundingBoundsDirty();
		int EFlags = GetEntData(iEntity, g_iEFlags);
		EFlags |= EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS;
		SetEntData(iEntity, g_iEFlags, EFlags);
	}
}

void RestoreEntityFromRecord(int iEntity, LagRecord Record)
{
	SetEntDataVector(iEntity, g_iVecOrigin, Record.vecOrigin);
	SetEntDataVector(iEntity, g_iVecAbsOrigin, Record.vecAbsOrigin);
	SetEntDataVector(iEntity, g_iAngRotation, Record.angRotation);
	SetEntDataVector(iEntity, g_iAngAbsRotation, Record.angAbsRotation);
	SetEntDataArray(iEntity, g_iCoordinateFrame, view_as<int>(Record.rgflCoordinateFrame), COORDINATE_FRAME_SIZE);
	SetEntDataFloat(iEntity, g_iSimulationTime, Record.flSimulationTime);

	InvalidatePhysicsRecursive(iEntity);
}


bool AddEntityForLagCompensation(int iEntity, bool bLateKill)
{
	if(g_bCleaningUp)
		return false;

	if(g_iNumEntities == MAX_ENTITIES)
	{
		char sClassname[64];
		GetEntityClassname(iEntity, sClassname, sizeof(sClassname));

		char sTargetname[64];
		GetEntPropString(iEntity, Prop_Data, "m_iName", sTargetname, sizeof(sTargetname));

		int iHammerID = GetEntProp(iEntity, Prop_Data, "m_iHammerID");

		PrintToBoth("[%d] OUT OF LAGCOMP SLOTS entity %d (%s)\"%s\"(#%d)", GetGameTickCount(), iEntity, sClassname, sTargetname, iHammerID);
		return false;
	}

	if(g_aLagCompensated[iEntity] != -1)
		return false;

	int i = g_iNumEntities;
	g_iNumEntities++;

	g_aLagCompensated[iEntity] = i;

	g_aEntityLagData[i].iEntity = iEntity;
	g_aEntityLagData[i].iRecordIndex = 0;
	g_aEntityLagData[i].iNumRecords = 1;
	g_aEntityLagData[i].iRecordsValid = 1;
	g_aEntityLagData[i].iSpawned = GetGameTickCount();
	g_aEntityLagData[i].iDeleted = 0;
	g_aEntityLagData[i].iNotMoving = MAX_RECORDS;
	g_aEntityLagData[i].bRestore = false;
	g_aEntityLagData[i].bLateKill = bLateKill;
	g_aEntityLagData[i].iTouchStamp = GetEntData(iEntity, g_iTouchStamp);

	if(bLateKill)
	{
		SetBit(g_aFilterTriggerTouch, iEntity);
	}

	RecordDataIntoRecord(iEntity, g_aaLagRecords[i][0]);

	{
		char sClassname[64];
		GetEntityClassname(iEntity, sClassname, sizeof(sClassname));

		char sTargetname[64];
		GetEntPropString(iEntity, Prop_Data, "m_iName", sTargetname, sizeof(sTargetname));

		int iHammerID = GetEntProp(iEntity, Prop_Data, "m_iHammerID");

		PrintToBoth("[%d] added entity %d (%s)\"%s\"(#%d) under index %d", GetGameTickCount(), iEntity, sClassname, sTargetname, iHammerID, i);
	}

	return true;
}

bool RemoveEntityFromLagCompensation(int iEntity)
{
	int index = g_aLagCompensated[iEntity];
	if(index == -1)
		return false;

	RemoveRecord(index);
	return true;
}

void RemoveRecord(int index)
{
	if(g_bCleaningUp)
		return;

	int iEntity = g_aEntityLagData[index].iEntity;

	if(IsValidEntity(iEntity))
	{
		char sClassname[64];
		GetEntityClassname(g_aEntityLagData[index].iEntity, sClassname, sizeof(sClassname));

		char sTargetname[64];
		GetEntPropString(g_aEntityLagData[index].iEntity, Prop_Data, "m_iName", sTargetname, sizeof(sTargetname));

		int iHammerID = GetEntProp(g_aEntityLagData[index].iEntity, Prop_Data, "m_iHammerID");

		PrintToBoth("[%d] RemoveRecord %d / %d (%s)\"%s\"(#%d), num: %d", GetGameTickCount(), index, g_aEntityLagData[index].iEntity, sClassname, sTargetname, iHammerID, g_iNumEntities);
	}

	g_aLagCompensated[iEntity] = -1;
	ClearBit(g_aFilterTriggerTouch, iEntity);
	ClearBit(g_aBlockTriggerMoved, iEntity);

	for(int client = 1; client <= MaxClients; client++)
	{
		ClearBit(g_aaFilterClientEntity, client * MAX_EDICTS + iEntity);
	}

	g_aEntityLagData[index].iEntity = INVALID_ENT_REFERENCE;

	for(int src = index + 1; src < g_iNumEntities; src++)
	{
		int dest = src - 1;

		EntityLagData_Copy(g_aEntityLagData[dest], g_aEntityLagData[src]);
		g_aEntityLagData[src].iEntity = INVALID_ENT_REFERENCE;
		g_aLagCompensated[g_aEntityLagData[dest].iEntity] = dest;

		int iNumRecords = g_aEntityLagData[dest].iNumRecords;
		for(int i = 0; i < iNumRecords; i++)
		{
			LagRecord_Copy(g_aaLagRecords[dest][i], g_aaLagRecords[src][i]);
		}
	}

	g_iNumEntities--;
}

void EntityLagData_Copy(EntityLagData obj, const EntityLagData other)
{
	obj.iEntity = other.iEntity;
	obj.iRecordIndex = other.iRecordIndex;
	obj.iNumRecords = other.iNumRecords;
	obj.iRecordsValid = other.iRecordsValid;
	obj.iSpawned = other.iSpawned;
	obj.iDeleted = other.iDeleted;
	obj.iNotMoving = other.iNotMoving;
	obj.iTouchStamp = other.iTouchStamp;
	obj.bRestore = other.bRestore;
	obj.bLateKill = other.bLateKill;

	LagRecord_Copy(obj.RestoreData, other.RestoreData);
}

void LagRecord_Copy(LagRecord obj, const LagRecord other)
{
	for(int i = 0; i < 3; i++)
	{
		obj.vecOrigin[i] = other.vecOrigin[i];
		obj.vecAbsOrigin[i] = other.vecAbsOrigin[i];
		obj.angRotation[i] = other.angRotation[i];
		obj.angAbsRotation[i] = other.angAbsRotation[i];
	}

	obj.flSimulationTime = other.flSimulationTime;

	for(int i = 0; i < COORDINATE_FRAME_SIZE; i++)
	{
		obj.rgflCoordinateFrame[i] = other.rgflCoordinateFrame[i];
	}
}

bool CompareVectors(const float vec1[3], const float vec2[3])
{
	return vec1[0] == vec2[0] && vec1[1] == vec2[1] && vec1[2] == vec2[2];
}


public Action Command_AddLagCompensation(int client, int argc)
{
	if(argc < 1)
	{
		ReplyToCommand(client, "[SM] Usage: sm_unlag <entidx> [late]");
		return Plugin_Handled;
	}

	char sArgs[32];
	GetCmdArg(1, sArgs, sizeof(sArgs));

	int entity = StringToInt(sArgs);

	bool late = false;
	if(argc >= 2)
	{
		GetCmdArg(2, sArgs, sizeof(sArgs));
		late = view_as<bool>(StringToInt(sArgs));
	}

	AddEntityForLagCompensation(entity, late);

	return Plugin_Handled;
}

public Action Command_CheckLagCompensated(int client, int argc)
{
	if(argc == 0)
	{
		for(int i = 0; i < g_iNumEntities; i++)
		{
			char sClassname[64];
			GetEntityClassname(g_aEntityLagData[i].iEntity, sClassname, sizeof(sClassname));

			char sTargetname[64];
			GetEntPropString(g_aEntityLagData[i].iEntity, Prop_Data, "m_iName", sTargetname, sizeof(sTargetname));

			int iHammerID = GetEntProp(g_aEntityLagData[i].iEntity, Prop_Data, "m_iHammerID");

			PrintToConsole(client, "%2d. #%d %s \"%s\" (#%d)", i, g_aEntityLagData[i].iEntity, sClassname, sTargetname, iHammerID);
		}

		return Plugin_Handled;
	}

	for(int iEntity = 0; iEntity < MAX_EDICTS; iEntity++)
	{
		bool bDeleted = false;
		for(int j = 1; j <= MaxClients; j++)
		{
			if(CheckBit(g_aaFilterClientEntity, j * MAX_EDICTS + iEntity))
			{
				bDeleted = true;
				break;
			}
		}

		bool bBlockPhysics = CheckBit(g_aFilterTriggerTouch, iEntity);
		bool bBlockTriggerMoved = CheckBit(g_aBlockTriggerMoved, iEntity);
		bool bBlacklisted = CheckBit(g_aBlacklisted, iEntity);

		if(bDeleted || bBlockPhysics || bBlockTriggerMoved || bBlacklisted)
		{
			int index = -1;
			for(int j = 0; j < g_iNumEntities; j++)
			{
				if(g_aEntityLagData[j].iEntity == iEntity)
				{
					index = j;
					break;
				}
			}

			char sClassname[64] = "INVALID";
			char sTargetname[64] = "INVALID";
			int iHammerID = -1;

			if(IsValidEntity(iEntity))
			{
				GetEntityClassname(iEntity, sClassname, sizeof(sClassname));
				GetEntPropString(iEntity, Prop_Data, "m_iName", sTargetname, sizeof(sTargetname));
				iHammerID = GetEntProp(iEntity, Prop_Data, "m_iHammerID");
			}

			PrintToConsole(client, "%2d. #%d %s \"%s\" (#%d) -> Phys: %d / TrigMov: %d / Deleted: %d / Black: %d",
				index, iEntity, sClassname, sTargetname, iHammerID, bBlockPhysics, bBlockTriggerMoved, bDeleted, bBlacklisted);
		}
	}

	return Plugin_Handled;
}


stock void PrintToBoth(const char[] format, any ...)
{
	char buffer[254];
	VFormat(buffer, sizeof(buffer), format, 2);
	LogMessage(buffer);

	for (int i = 1; i <= MaxClients; i++)
	{
		if (IsClientInGame(i))
		{
			PrintToConsole(i, "%s", buffer);
		}
	}
}