#include <sourcemod>
#include <sdkhooks>
#include <tf2>
#include <tf2_stocks>
#include <sdktools>

#undef REQUIRE_PLUGIN
#include <adminmenu>
#define REQUIRE_PLUGIN

//* * * * * * * * * * * * * * * * * * * * * * * * * *
//Defines
//* * * * * * * * * * * * * * * * * * * * * * * * * *
//- The default Field of Vision to apply to clients.
#define cDefaultVision 90

//* * * * * * * * * * * * * * * * * * * * * * * * * *
//Handles
//* * * * * * * * * * * * * * * * * * * * * * * * * *
new Handle:h_Mode = INVALID_HANDLE;             //ConVar for fov order.
new Handle:h_MaxValue = INVALID_HANDLE;         //ConVar for max fov.
new Handle:h_MinValue = INVALID_HANDLE;         //ConVar for min fov.
new Handle:hTopMenu = INVALID_HANDLE;           //AdminMenu

//* * * * * * * * * * * * * * * * * * * * * * * * * *
//Variables
//* * * * * * * * * * * * * * * * * * * * * * * * * *
new g_bEnding;                                  //Stores the state of round end.
new g_bLateLoad;                                //Stores the state of load.

//* * * * * * * * * * * * * * * * * * * * * * * * * *
//Clients
//* * * * * * * * * * * * * * * * * * * * * * * * * *
new g_iCurrentVision[MAXPLAYERS + 1] = { cDefaultVision, ... };         //Stores current FoV.
new bool:g_bActiveVision[MAXPLAYERS + 1];       //Stores whether FoV is modified.
new bool:g_bForcedVision[MAXPLAYERS + 1];       //Stores whether FoV is active from admin.
new bool:g_bZoomVision[MAXPLAYERS + 1];         //

public Plugin:myinfo =
{
    name = "Strange FoV",
    author = "Benjamin",
    description = "What the fuuuuuuuuuuuuuuuuu...",
    version = "1.1",
    url = "http://steamcommunity.com/id/BenjaminHT/"
}

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

public OnPluginStart()
{
    LoadTranslations("common.phrases");
    //LoadTranslations("sFoV_player.phrases");

    h_Mode = CreateConVar("sm_sfov_mode", "1", "Max FoV.", FCVAR_PLUGIN, true, 1.0, true, 2.0);
    h_MaxValue = CreateConVar("sm_sfov_max", "170", "Max FoV.", FCVAR_PLUGIN, true, 90.0, true, 180.0);
    h_MinValue = CreateConVar("sm_sfov_min", "20", "Min FoV.", FCVAR_PLUGIN, true, 0.0, true, 90.0);

    RegAdminCmd("sm_fov", Command_Vision, ADMFLAG_SLAY);

    AddCommandListener(attack2CallBack, "-attack2");

    //Client Events
    HookEvent("player_spawn", Event_OnPlayerSpawn);
    HookEvent("player_death", Event_OnPlayerDeath);
    HookEvent("player_team", Event_OnPlayerTeam);

    //Round Events
    HookEvent("teamplay_round_start", Event_OnRoundStart);
    HookEvent("teamplay_round_win", Event_OnRoundEnd);
    HookEvent("arena_round_start", Event_OnRoundStart);
    HookEvent("arena_win_panel", Event_OnRoundEnd);

    new Handle:topmenu;
    if (LibraryExists("adminmenu") && ((topmenu = GetAdminTopMenu()) != INVALID_HANDLE))
    {
        OnAdminMenuReady(topmenu);
    }
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires when the plugin is unloaded.
public OnPluginEnd()
{
    for(new i = 1; i <= MaxClients; i++)
    {
        if(!IsClientInGame(i) || IsFakeClient(i))
            continue;

        //Disable the vision effect for anyone that has it enabled.
        if(g_bActiveVision[i])
        {
            SetClientVision(i, 0);
        }
    }
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires after OnMapStart when all configs are executed.
public OnConfigsExecuted()
{
    if(g_bLateLoad)
    {
        //Loop through valid clients, hook them.
        for(new i = 1; i <= MaxClients; i++)
        {
            if(!IsClientInGame(i) || IsFakeClient(i))
                continue;

            SDKHook(i, SDKHook_PostThink, OnPostThink);
        }

        g_bLateLoad = false;
    }
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires at the start of a new map, or after the plugin has been loaded.
public OnMapStart()
{
    //Set the end of the round to False.
    g_bEnding = false;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires at the end of the map, after everyone has disconnected but before map changes.
public OnMapEnd()
{
    //Set the end of the round to True.
    g_bEnding = true;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires when a client physically disconnects or when the map is changing.
public OnClientDisconnect(client)
{
    //Ignore if it wasn't a valid client (rare).
    if(!IsClientInGame(client))
        return;

    //Reset data back to defaults for next client.
    g_bActiveVision[client] = false;
    g_bForcedVision[client] = false;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires when a client is officially in-game and is a valid target.
public OnClientPutInServer(client)
{
    //Ignore if it wasn't a valid client (rare).
    if(!IsClientInGame(client))
        return;

    g_iCurrentVision[client] = cDefaultVision;
    SDKHook(client, SDKHook_PostThink, OnPostThink);
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* SDKHook_PostThink CallBack
public OnPostThink(client)
{
    //Ignore if ending, their vision is disabled, they're in the process of disconnecting, or dying.
    if(g_bEnding || !g_bActiveVision[client] || !IsClientInGame(client) || !IsPlayerAlive(client))
        return;

    //If they're zooming, ignore.
    if(TF2_IsPlayerInCondition(client, TFCond_Zoomed))
        return;

    //If their current vision is negative, don't use that value!
    new iVision = g_iCurrentVision[client];
    if(iVision < 0)
    {
        iVision *= -1;
    }

    //Apply the FoV.
    SetEntProp(client, Prop_Send, "m_iFOV", iVision);

    //Determine FoV order
    switch(GetConVarInt(h_Mode))
    {
        case 1:
        {
            //If the client is at the upper bounds, reverse.
            if(iVision >= GetConVarInt(h_MaxValue))
            {
                //If their vision is 170, set it to -170 so that it counts down.
                g_iCurrentVision[client] *= -1;
            }

            //If the client is at the lower bounds, reverse.
            if(iVision <= GetConVarInt(h_MinValue))
            {
                //If their vision is -20, set it to 20 so that it counts up
                g_iCurrentVision[client] *= -1;
            }
        }
        case 2:
        {
            if(g_iCurrentVision[client] >= GetConVarInt(h_MaxValue))
            {
                g_iCurrentVision[client] = GetConVarInt(h_MinValue);
            }
        }
    }

    //Increment their current FoV by one every frame.
    g_iCurrentVision[client] += 1;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires at the end of Team Play or Arena. (Can't Confirm)
public Action:Event_OnRoundEnd(Handle:event, const String:name[], bool:dontBroadcast)
{
    //Set the end of the round to True.
    g_bEnding = true;

    //Loop through all active players in-game.
    for (new i = 1; i < MaxClients; i++)
    {
        if(!IsClientInGame(i) || IsFakeClient(i))
            continue;

        //Disable any active effects, reset their vision.
        if(g_bActiveVision[i])
        {
            SetClientVision(i, 0);
        }
    }
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires at the start of Team Play or Arena. (Can't Confirm)
public Action:Event_OnRoundStart(Handle:event, const String:name[], bool:dontBroadcast)
{
    //Set the end of the round to false.
    g_bEnding = false;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires on connection as well as every time a player spawns.
public Action:Event_OnPlayerSpawn(Handle:event, const String:name[], bool:dontBroadcast)
{
    //Get the client from the event.
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    if(!client || !IsClientInGame(client))
    {
        return Plugin_Continue;
    }

    //Ignore any spawning attempts while the player is not alive (i.e. connecting)
    if(!IsPlayerAlive(client))
    {
        return Plugin_Continue;
    }

    //Re-apply the FoV effect if the client has had their state enabled.
    if(g_bForcedVision[client])
    {
        SetClientVision(client, g_iCurrentVision[client]);
    }

    return Plugin_Continue;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires whenever a player dies in-game.
public Action:Event_OnPlayerDeath(Handle:event, const String:name[], bool:dontBroadcast)
{
    //Get the client from the event.
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    if(!client || !IsClientInGame(client))
    {
        return Plugin_Continue;
    }

    //Reset the client's FoV if they had an active effect & disable it.
    if(g_bActiveVision[client])
    {
        SetClientVision(client, 0);
    }

    return Plugin_Continue;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Fires whenever a player changes their team.
public Action:Event_OnPlayerTeam(Handle:event, const String:name[], bool:dontBroadcast)
{
    //Get the client from the event.
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    if(!client || !IsClientInGame(client))
    {
        return Plugin_Continue;
    }

    //Reset the client's FoV if they join Spectate.
    if(GetEventInt(event, "team") == _:TFTeam_Spectator)
    {
        SetClientVision(client, 0);
    }
    //Re-apply the FoV effect on team change just to be safe.
    else if(g_bForcedVision[client])
    {
        SetClientVision(client, g_iCurrentVision[client]);
    }

    return Plugin_Continue;
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Simple stock for modifying the client's FoV.
stock SetClientVision(client, range)
{
    if(range == 0)
    {
        g_bActiveVision[client] = false;
        if(!TF2_IsPlayerInCondition(client, TFCond_Zoomed))
            SetEntProp(client, Prop_Send, "m_iFOV", cDefaultVision);
    }
    else
    {
        g_bActiveVision[client] = true;
        if(!TF2_IsPlayerInCondition(client, TFCond_Zoomed))
            SetEntProp(client, Prop_Send, "m_iFOV", range);
    }
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* CallBack for the vision command.
public Action:Command_Vision(client, args)
{
    //Ignore the command if it's used during the end of the round.
    if(g_bEnding)
    {
        ReplyToCommand(client, "[SM] This command can only be used during the round!");
        return Plugin_Handled;
    }

    if(!args)
    {
        //Console has no reason to toggle effects, nor do invalid clients.
        if(!client || GetClientTeam(client) <= _:TFTeam_Spectator || !IsPlayerAlive(client))
        {
            ReplyToCommand(client, "[SM] This command cannot be toggled on invalid clients!");
            return Plugin_Handled;
        }

        //Check to see if the client has self-access.
        if(client && !CheckCommandAccess(client, "StrangeFoVSelf", ADMFLAG_GENERIC))
        {
            ReplyToCommand(client, "[SM] Usage: sm_fov");
            return Plugin_Handled;
        }

        g_bForcedVision[client] = !g_bForcedVision[client];
        ShowActivity2(client, "[SM] ", "Set his/her StrangeFoV state to %s", g_bForcedVision[client] ? "on" : "off");
        LogAction(client, client, "%L set his/her StrangeFoV state to %s", client, g_bForcedVision[client] ? "on" : "off");
        if(g_bForcedVision[client])
            SetClientVision(client, g_iCurrentVision[client]);
        else
            SetClientVision(client, 0);

        return Plugin_Handled;
    }

    if(args)
    {
        //Notify on the event of invalid.
        if(args > 2)
        {
            ReplyToCommand(client, "[SM] This command cannot be toggled on invalid clients!");
            return Plugin_Handled;
        }

        //Check to see if the client has other-access.
        if(client && !CheckCommandAccess(client, "StrangeFoVOther", ADMFLAG_GENERIC))
        {
            ReplyToCommand(client, "[SM] Usage: sm_fov <target> [optional: 0|1]");
            return Plugin_Handled;
        }

        //Declare necessary information to process command; grab argument string.
        decl iBreak, String:sText[192], String:sPattern[64], String:sBuffer[64];
        new iTargets[MAXPLAYERS + 1], bool:bTemp, bool:bState;
        GetCmdArgString(sText, sizeof(sText));

        //Store pattern, check to see if there's an additional argument.
        iBreak = BreakString(sText, sPattern, sizeof(sPattern));
        if(iBreak != -1)
        {
            iBreak += BreakString(sText[iBreak], sBuffer, sizeof(sBuffer));
            bState = bool:StringToInt(sBuffer);
        }

        //Only let the command target non-bots currently in-game.
        new iCount = ProcessTargetString(sPattern, client, iTargets, sizeof(iTargets), COMMAND_FILTER_NO_BOTS|COMMAND_FILTER_CONNECTED, sBuffer, sizeof(sBuffer), bTemp);
        if(iCount)
        {
            //Loop through all clients currently in-game.
            for (new i = 0; i < iCount; i++)
            {
                if(!IsClientInGame(iTargets[i]))
                {
                    continue;
                }

                //BreakString returns -1 if there was no string to break, thus 1 parameter.
                if(iBreak == -1)
                {
                    //No parameters, so toggle the client's current state.
                    if(g_bForcedVision[iTargets[i]])
                    {
                        SetClientVision(iTargets[i], 0);
                    }
                    else
                    {
                        SetClientVision(iTargets[i], g_iCurrentVision[iTargets[i]]);
                    }

                    g_bForcedVision[iTargets[i]] = !g_bForcedVision[iTargets[i]];
                    LogAction(client, iTargets[i], "%L set StrangeFoV on %L to %s", client, iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
                    ShowActivity2(client, "[SM] ", "Set StrangeFoV on %N to %s", iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
                }
                else
                {
                    //Second argument was specified, force whatever values are desired.
                    if(bState)
                    {
                        //It's being enabled, ignore anyone that already has it.
                        if(g_bForcedVision[iTargets[i]])
                        {
                            if(!g_bActiveVision[iTargets[i]])
                                SetClientVision(iTargets[i], g_iCurrentVision[iTargets[i]]);

                            continue;
                        }

                        g_bForcedVision[iTargets[i]] = true;
                        SetClientVision(iTargets[i], g_iCurrentVision[iTargets[i]]);
                        LogAction(client, iTargets[i], "%L set StrangeFoV on %L to %s", client, iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
                        ShowActivity2(client, "[SM] ", "Set StrangeFoV on %N to %s", iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
                    }
                    else
                    {
                        //It's being disabled, ignore anyone that already doesn't have it.
                        if(!g_bForcedVision[iTargets[i]])
                        {
                            if(g_bActiveVision[iTargets[i]])
                                SetClientVision(iTargets[i], 0);

                            continue;
                        }

                        g_bForcedVision[iTargets[i]] = false;
                        SetClientVision(iTargets[i], 0);
                        LogAction(client, iTargets[i], "%L set StrangeFoV on %L to %s", client, iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
                        ShowActivity2(client, "[SM] ", "Set StrangeFoV on %N to %s", iTargets[i], g_bForcedVision[iTargets[i]] ? "on" : "off");
                    }
                }
            }
        }
    }

    return Plugin_Handled;
}

public Action:attack2CallBack(client, const String:command[], argc)
{
    g_bForcedVision[client] = !g_bForcedVision[client];
    if(GetEntProp(client, Prop_Send, "m_iFOV") == 90 && g_bForcedVision[client] == false)
    {
        g_bZoomVision[client] = false;
    }
    else
    {
        g_bZoomVision[client] = true;
    }
    if(GetEntProp(client, Prop_Send, "m_iFOV") == 90 && g_bForcedVision[client] == true)
    {
        g_bForcedVision[client] = !g_bForcedVision[client];
    }
}

public OnAdminMenuReady(Handle:topmenu)
{
    /* Block us from being called twice */
    if (topmenu == hTopMenu)
    {
        return;
    }

    /* Save the Handle */
    hTopMenu = topmenu;

    /* Build the "Player Commands" category */
    new TopMenuObject:player_commands = FindTopMenuCategory(hTopMenu, ADMINMENU_PLAYERCOMMANDS);

    if (player_commands != INVALID_TOPMENUOBJECT)
    {
        AddToTopMenu(hTopMenu,
            "sm_fov",
            TopMenuObject_Item,
            AdminMenu_FoV,
            player_commands,
            "sm_fov",
            ADMFLAG_SLAY);
    }
}

public OnLibraryRemoved(const String:name[])
{
    if (strcmp(name, "adminmenu") == 0)
    {
        hTopMenu = INVALID_HANDLE;
    }
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* AdminMenu Callback - Only re-written cause of OCD.
public AdminMenu_FoV(Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
{
    switch(action)
    {
        case TopMenuAction_DisplayOption:
        {
            Format(buffer, maxlength, "Set Strange FoV", param);
            //Format(buffer, maxlength, "%T", "sFoV player", param);
        }
        case TopMenuAction_SelectOption:
        {
            DisplayFoVMenu(param);
        }
    }
}

DisplayFoVMenu(client)
{
    new Handle:hMenu = CreateMenu(MenuHandler_FoV);

    decl String:sBuffer[128], String:sDisplay[64], String:sUser[4];
    Format(sBuffer, sizeof(sBuffer), "Select Player:", client);
    //Format(sBuffer, sizeof(sBuffer), "%T:", "sFoV player", client);
    SetMenuTitle(hMenu, sBuffer);
    SetMenuExitBackButton(hMenu, true);

    //These should be translations, but for now, just graphics.
    new String:sActive[] = "[*]";
    new String:sDisabled[] = "[  ]";

    //Loop through all active clients. Ignore bots and players the admin can't target.
    // We're making our own loop instad of using AddTargetsToMenu to display the state
    //  of the effect prior to toggling.

    for(new i = 1; i <= MaxClients; i++)
    {
        if(!IsClientInGame(i) || IsFakeClient(i) || (client != i && !CanUserTarget(client, i)))
            continue;

        //Format the string so it shows who has it enabled/disabled.
        //1) [ ] Panda
        //2) [*] Benja
        Format(sDisplay, sizeof(sDisplay), "%s %N", g_bForcedVision[i] ? sActive : sDisabled, i);

        //Pass the userid along so it's available.
        IntToString(GetClientUserId(i), sUser, sizeof(sUser));
        AddMenuItem(hMenu, sUser, sDisplay);
    }

    DisplayMenu(hMenu, client, MENU_TIME_FOREVER);
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//* Menu Callback - Only re-written cause of OCD.
public MenuHandler_FoV(Handle:menu, MenuAction:action, param1, param2)
{
    switch(action)
    {
        case MenuAction_End:
        {
            CloseHandle(menu);
        }
        case MenuAction_Cancel:
        {
            if (param2 == MenuCancel_ExitBack && hTopMenu != INVALID_HANDLE)
            {
                DisplayTopMenu(hTopMenu, param1, TopMenuPosition_LastCategory);
            }
        }
        case MenuAction_Select:
        {
            decl String:info[32];
            GetMenuItem(menu, param2, info, sizeof(info));

            new userid = StringToInt(info);
            new target = GetClientOfUserId(userid);

            if(!target)
            {
                PrintToChat(param1, "[SM] The player you were targeting is no longer available.");
                //PrintToChat(param1, "[SM] %t", "Player no longer available");
            }
            else if(!CanUserTarget(param1, target))
            {
                PrintToChat(param1, "[SM] You are unable to target %N!", target);
                //PrintToChat(param1, "[SM] %t", "Unable to target");
            }
            else
            {
                //Toggle the effect based on the current state.
                if(g_bForcedVision[target])
                    SetClientVision(target, 0);
                else
                    SetClientVision(target, g_iCurrentVision[target]);

                g_bForcedVision[target] = !g_bForcedVision[target];
                LogAction(param1, target, "%L set StrangeFoV on %L to %s", param1, target, g_bForcedVision[target] ? "on" : "off");
                ShowActivity2(param1, "[SM] ", "Set StrangeFoV on %N to %s", target, g_bForcedVision[target] ? "on" : "off");
            }

            //Display the menu back to the admin, if possible.
            if (IsClientInGame(param1) && !IsClientInKickQueue(param1))
            {
                DisplayFoVMenu(param1);
            }
        }
    }
}