#include sdktools
#include sdkhooks

new bool:IsHealer[MAXPLAYERS+1] = false;
new bool:IsUsing = false;
static Handle hHealCount, hMaxHealth, hDurationRing, hDistance;

Handle HealTimer[MAXPLAYERS+1];

int g_HaloSprite;
int g_BeamSprite;
int yourColor[4] = {220, 20, 60, 255};

public OnPluginStart()
{
    hHealCount = CreateConVar("hCvarHealCount", "5", "Кол-во лечения", FCVAR_NONE, true, 1.0, true, 50000.0);
    hMaxHealth = CreateConVar("hCvarMaxHeal", "75", "Максимальный прохил", FCVAR_NONE);
    hDurationRing = CreateConVar("hCvarDuration", "15.0", "Время жизни кольца", FCVAR_NONE, true, 1.0, true, 25.0)
    hDistance = CreateConVar("hCvarDuration", "600.0", "Дистаннция", FCVAR_NONE)
    //CoolDown = CreateConVar("hCvarCoolDown", "15.0", "Кул даун юзания", FCVAR_NONE)
    AutoExecConfig(true, "hMedicPlug");
}

public OnMapStart()
{
    HookEvent("bullet_impact", hImpact)
    HookEvent("player_afk", hAfkFix)
    HookEvent("player_death", hDeath)
    CreateTimer(30.0, hSetMedic, TIMER_FLAG_NO_MAPCHANGE)

    g_BeamSprite = PrecacheModel("materials/sprites/laserbeam.vmt", true);
    g_HaloSprite = PrecacheModel("materials/sprites/halo01.vmt", true);
}

public hDeath(Handle:event, const String:name[], bool:dontBroadcast)
{
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    if(IsHealer[client])
    {
        PrintToChatAll("Медик погиб в перестрелке(земля ему пухом)", client)
    }
}

public hAfkFix(Handle:event, const String:name[], bool:dontBroadcast)
{
    new client = GetClientOfUserId(GetEventInt(event, "player"));
    if(IsHealer[client])
    {
        IsHealer[client] = false;
        new healer = GetAnyRandomSurvivor()
        IsHealer[healer] = true;
        PrintToChatAll("Медик %N отошёл от игры", client);
        PrintToChatAll("%N стал новым медиком", healer);
    }
}

public hImpact(Handle:event, const String:name[], bool:dontBroadcast)
{
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    new Float:f_Pos[3];
    f_Pos[0] = GetEventFloat(event, "x");
    f_Pos[1] = GetEventFloat(event, "y");
    f_Pos[2] = GetEventFloat(event, "z");

    f_Pos[2] += 15;
    if(IsUsing != true)
    {
        if(bIsSurvivor(client))
        {
            new weap = GetPlayerWeaponSlot(client, 1)
            char sWeaponEx[32];
            GetEntityClassname(weap, sWeaponEx, sizeof(sWeaponEx))
            if(StrEqual(sWeaponEx, "weapon_pistol_magnum"))
            {
                if(IsHealer[client])
                {
                    TE_SetupBeamRingPoint(f_Pos, 600.0, 605.0, g_BeamSprite, g_HaloSprite, 0, 66, GetConVarFloat(hDurationRing), 4.2, 1.0, yourColor, 20, 0)
                    TE_SendToAll();
                    new Handle:vPosition;
                    CreateDataTimer(3.0, TimerRing, vPosition, TIMER_REPEAT)

                    WritePackFloat(vPosition, f_Pos[0]);
                    WritePackFloat(vPosition, f_Pos[1]);
                    WritePackFloat(vPosition, f_Pos[2]);

                    new Handle:pack;
                    HealTimer[client] = CreateDataTimer(1.0, Healing, pack, TIMER_REPEAT);
                    IsUsing = true;
                    WritePackCell(pack, client);
                    WritePackFloat(pack, f_Pos[0]);
                    WritePackFloat(pack, f_Pos[1]);
                    WritePackFloat(pack, f_Pos[2]);
                    WritePackFloat(pack, GetEngineTime());


                //  CreateTimer(GetConVarFloat(hDurationRing), KillHeal, client);
                }
            }
        }
    }
}

public Action:TimerRing(Handle:timer, vPosition)
{
    float vPos[3];
    ResetPack(vPosition);
    vPos[0] = ReadPackFloat(vPosition);
    vPos[1] = ReadPackFloat(vPosition);
    vPos[2] = ReadPackFloat(vPosition);

    TE_SetupBeamRingPoint(vPos, 0.0, 600.0, g_BeamSprite, g_HaloSprite, 0, 66, 4, 4.2, 1.0, yourColor, 90, 0)
    TE_SendToAll();
}

public Action:Healing(Handle:timer, Handle:pack)
{
    float bPos[3], vPos[3];

    ResetPack(pack);
    new client = ReadPackCell(pack);
    bPos[0] = ReadPackFloat(pack);
    bPos[1] = ReadPackFloat(pack);
    bPos[2] = ReadPackFloat(pack);
    new Float:time=ReadPackFloat(pack);

    if(GetEngineTime() - time < GetConVarFloat(hDurationRing))
    {
        for (new i = 1; i <= MaxClients; i++)
        {
            if(bIsSurvivor(i))
            {
                GetEntPropVector(i, Prop_Send, "m_vecOrigin", vPos);
                float fTargetDistance = GetVectorDistance(bPos, vPos);
                if (fTargetDistance > GetConVarFloat(hDistance)) continue;
                new HP = GetClientHealth(i);
                if(HP < GetConVarInt(hMaxHealth))
                {
                    SetEntityHealth(client, HP + GetConVarInt(hHealCount))
                }
            }
        }
    }
    else
    {
        IsUsing = false;
        KillTimer(HealTimer[client]);
        HealTimer[client] = INVALID_HANDLE;
    }
}

public Action:hSetMedic(Handle timer, any fuck)
{
    new client = GetAnyRandomSurvivor()
    if(client > 0)
    {
        IsHealer[client] = true;
        GiveFunction(client, "pistol_magnum")
        PrintToChatAll("%N стал медиком", client);
    }
}

public OnClientPutInServer(client)
{
    //SDKHook(client, SDKHook_OnTakeDamage, OnTakeDamage);
    SDKHook(client, SDKHook_WeaponCanUse, WeaponCanUse);
}

public OnClientDisconnect(client)
{
    //SDKUnhook(client, SDKHook_OnTakeDamage, OnTakeDamage);
    SDKUnhook(client, SDKHook_WeaponCanUse, WeaponCanUse);
    if(IsHealer[client] == true)
    {
        IsHealer[client] = false;
        new healer = GetAnyRandomSurvivor()
        IsHealer[healer] = true;
        PrintToChatAll("Медик %N покинул игру", client);
        PrintToChatAll("%N стал новым медиком", healer);
    }

    if (HealTimer[client] != INVALID_HANDLE)
    {
        KillTimer(HealTimer[client]);
        HealTimer[client] = INVALID_HANDLE;
    }
}

public Action:WeaponCanUse(client, weapon)
{
    if(bIsSurvivor(client))
    {
        if(IsHealer[client])
        {
            new wepn = GetPlayerWeaponSlot(client, 1)
            if (!IsValidEntity(wepn))
            {
                return Plugin_Continue;
            }
            decl String:sWeaponEx[32];
            GetEntityClassname(wepn, sWeaponEx, sizeof(sWeaponEx));

            new String:sClassName[64];
            GetEntityClassname(weapon, sClassName, sizeof(sClassName));

            if(StrEqual(sWeaponEx, "weapon_pistol_magnum"))
            {
                if(StrEqual(sClassName, "weapon_melee") || StrEqual(sClassName, "weapon_pistol"))
                {
                    return Plugin_Handled;
                }
            }
        }
    }
    return Plugin_Continue;
}

/*
public Action:OnTakeDamage(victim, &attacker, &inflictor, &Float:damage, &damagetype)
{
    if(bIsSurvivor(victim) && bIsSurvivor(attacker))
    {
        if(IsHealer[attacker] == true)
        {
            decl String:classname[64];
            GetClientWeapon(attacker, classname, sizeof(classname));
            if(StrEqual(classname, "weapon_pistol_magnum"))
            {
                damage = 0.0
                int heal = GetClientHealth(victim)
                if(GetConVarInt(hMaxHealth) < heal)
                {
                    SetEntityHealth(victim, GetConVarInt(hHealCount) + 4);
                }
            }
        }
    }
}
*/

stock GetAnyRandomSurvivor()
{
    new electables = 0, pool[4];
    for (new player = 1; player <= MaxClients; player++)
    {
        if (player > 0 && bIsSurvivor(player))
        {
            pool[electables] = player;
            electables += 1;
        }
    }
    return pool[GetRandomInt(0, electables)];
}

void GiveFunction(int client, char[] name)
{
    char sBuf[32];
    int flags = GetCommandFlags("give");
    SetCommandFlags("give", flags & ~FCVAR_CHEAT);
    FormatEx(sBuf, sizeof sBuf, "give %s", name);
    FakeClientCommand(client, sBuf);
}

stock bool bIsSurvivor(int client)
{
    return client > 0 && client <= MaxClients && IsClientInGame(client) && GetClientTeam(client) == 2 && !IsClientInKickQueue(client) && !IsFakeClient(client) && IsPlayerAlive(client);
}