#pragma semicolon 1
#include <sourcemod>
#include <sdktools>

static Handle:trieModdedWeapons                     =   INVALID_HANDLE;

static      damageModEnabled                        =   1;
static      damageModEnabledForCI                   =   1;
static bool:ignoreNextDamageDealt[MAXPLAYERS+1]     =   false;

public OnPluginStart()
{
    RegAdminCmd("sm_damage_weaponmulti", CmdSetWeaponMultiplier, ADMFLAG_CHEATS);
    HookEvent("infected_hurt", _DM_InfectedHurt_Event);
    trieModdedWeapons = CreateTrie();
}

public Action:_DM_InfectedHurt_Event(Handle:event, const String:name[], bool:dontBroadcast)
{
    decl Float:multiplierWeapon, String:weaponname[64];

    new attacker = GetClientOfUserId(GetEventInt(event, "attacker"));
    new entity = (GetEventInt(event, "entityid"));

    if (!attacker || !IsValidEntity(entity) || ignoreNextDamageDealt[attacker]) return;

    decl String:entname[32];
    GetEdictClassname(entity, entname, sizeof(entname));

    new dmg_health = GetEventInt(event,"amount");
    new eventhealth = GetEntProp(entity, Prop_Data, "m_iHealth");
    new damagedelta;

    if (dmg_health < 1 || eventhealth < 1) return;

    GetClientWeapon(attacker, weaponname, sizeof(weaponname));

    if (StrEqual(weaponname, "weapon_melee"))
    {
        if (StrEqual(entname, "infected", false) && !damageModEnabledForCI) return;

        GetEntPropString(GetPlayerWeaponSlot(attacker, 1), Prop_Data, "m_strMapSetScriptName", weaponname, sizeof(weaponname));
    }

    if(GetTrieValue(trieModdedWeapons, weaponname, multiplierWeapon))
    {
        damagedelta = RoundToNearest((dmg_health * multiplierWeapon) - dmg_health);

        switch (damagedelta > 0)
        {
            case true:
            {
                applyDamage(damagedelta, entity, attacker);
            }
            case false:
            {
                new health = eventhealth - damagedelta;

                if (health < 1)
                {
                    damagedelta += (health - 1);
                    health = 1;
                }

                SetEntProp(entity, Prop_Data, "m_iHealth", health);
                SetEventInt(event, "amount", damagedelta);

            }
        }
    }
}

public Action:CmdSetWeaponMultiplier(client, args)
{
    if (!damageModEnabled) return Plugin_Handled;

    decl String:weapon[64], String:multiplier[20];

    if (args == 2)
    {
        GetCmdArg(1, weapon, sizeof(weapon));
        GetCmdArg(2, multiplier, sizeof(multiplier));

        SetTrieValue(trieModdedWeapons, weapon, StringToFloat(multiplier));
        ReplyToCommand(client, "Successfully set damage of weapon: %s to %.2f!", weapon, StringToFloat(multiplier));
    }
    else if (client)
    {
        decl String:weaponname[64];
        GetClientWeapon(client, weaponname, sizeof(weaponname));

        if (StrEqual(weaponname, "weapon_melee"))
        {
            GetEntPropString(GetPlayerWeaponSlot(client, 1), Prop_Data, "m_strMapSetScriptName", weaponname, sizeof(weaponname));
        }

        ReplyToCommand(client,"Usage: sm_damage_weapon <weapon> <multiplier> - your current weapon is %s", weaponname);
    }
    else ReplyToCommand(client,"Usage: sm_damage_weapon <weapon> <multiplier>");

    return Plugin_Handled;
}

static applyDamage(damage, victim, attacker)
{
    new Handle:dataPack = CreateDataPack();
    WritePackCell(dataPack, damage);
    WritePackCell(dataPack, victim);
    WritePackCell(dataPack, attacker);

    CreateTimer(0.1, timer_stock_applyDamage, dataPack);
    ignoreNextDamageDealt[attacker] = true;
    CreateTimer(0.2, timer_resetStop, attacker);
}

public Action:timer_resetStop(Handle:timer, any:client)
{
    ignoreNextDamageDealt[client] = false;
}

public Action:timer_stock_applyDamage(Handle:timer, Handle:dataPack)
{
    ResetPack(dataPack);
    new damage = ReadPackCell(dataPack);
    new victim = ReadPackCell(dataPack);
    new attacker = ReadPackCell(dataPack);
    CloseHandle(dataPack);

    decl Float:victimPos[3], String:strDamage[16], String:strDamageTarget[16];

    if (victim < 20 && IsClientInGame(victim))
    {
        GetClientEyePosition(victim, victimPos);
    }
    else if (IsValidEntity(victim))
    {
        GetEntityAbsOrigin(victim, victimPos);
    }
    else return;

    IntToString(damage, strDamage, sizeof(strDamage));
    Format(strDamageTarget, sizeof(strDamageTarget), "hurtme%d", victim);

    new entPointHurt = CreateEntityByName("point_hurt");
    if(!entPointHurt) return;

    DispatchKeyValue(victim, "targetname", strDamageTarget);
    DispatchKeyValue(entPointHurt, "DamageTarget", strDamageTarget);
    DispatchKeyValue(entPointHurt, "Damage", strDamage);
    DispatchKeyValue(entPointHurt, "DamageType", "0");
    DispatchSpawn(entPointHurt);

    TeleportEntity(entPointHurt, victimPos, NULL_VECTOR, NULL_VECTOR);
    AcceptEntityInput(entPointHurt, "Hurt", (attacker && attacker < 20 && IsClientInGame(attacker)) ? attacker : -1);

    DispatchKeyValue(entPointHurt, "classname", "point_hurt");
    DispatchKeyValue(victim, "targetname", "null");
    RemoveEdict(entPointHurt);
}

stock GetEntityAbsOrigin(entity,Float:origin[3])
{
    if (entity > 0 && IsValidEntity(entity))
    {
        decl Float:mins[3], Float:maxs[3];
        GetEntPropVector(entity,Prop_Send,"m_vecOrigin",origin);
        GetEntPropVector(entity,Prop_Send,"m_vecMins",mins);
        GetEntPropVector(entity,Prop_Send,"m_vecMaxs",maxs);

        origin[0] += (mins[0] + maxs[0]) * 0.5;
        origin[1] += (mins[1] + maxs[1]) * 0.5;
        origin[2] += (mins[2] + maxs[2]) * 0.5;
    }
}