#include <sourcemod>
#include <sdktools>
#include <cstrike>
#include "socket.inc"

#define MY_SOCKET_IP "localhost"
//#define MY_SOCKET_IP "127.0.0.1"
#define MY_SOCKET_PORT 3000
#define STEAMID_LENGTH 128

char teamCT[5][150];
char teamT[5][150];
char clientId[128];

int allId[20];
int nbAllId = 0;

int port = -1;

public Plugin myinfo = 
{
    name = "InfoLan 2021 Bot",
    author = "rick@gnous.eu",
    description = "Bot communiquant avec le bot discord \ 
            https://github.com/Lunki51/cs-picker afin d’automatiser \
            l’InfoLan 2021",
    version = "1.5.7",
    url = "https://git.gnous.eu/Rick/infolanBot"
};

public void OnPluginStart()
{
    HookEvent("player_activate", SetTeamPlayer);
    HookEvent("cs_win_panel_round", UpdateScoreBoard);
    HookEvent("cs_win_panel_match", FinCarte);
    //HookEvent("cs_match_end_restart", TestRestart, EventHookMode_Pre);

    RegServerCmd("!team", SetTeam);
    /* pour le debug
    RegServerCmd("!tests", TestSocket);
    RegServerCmd("!testsA", TestSocketA);
    */

    PrintToServer("Hello world!");
}

/**
 * Fonction trigger par l’event cs_win_panel_matchk
 * Envoie l’information que le match est fini.
 */
public void FinCarte(Event event, const char[] name, bool dontBroadcast)
{
    ServeurLibre();
}

/**
 * Commande pour tester le redémarrage d’une partie (kick des personnes, 
 * notification au bot…)
 */
public void TestRestart(Event event, const char[] name, bool dontBroadcast)
{
    // TODO kick tout le monde
    PrintToServer("======= FIN ======");
    for (int i = 0; i < nbAllId; i++)
    {
        PrintToServer("On kick %d.", allId[i]);
        if (IsClientInGame(allId[i])) {
            PrintToServer("NUUUUUUUL");
            KickClient(allId[i], "Le match est fini.");
        }
        allId[i] = 0;
    }
    ServeurLibre();
    nbAllId = 0;
    /* kick tout le monde */
}

/**
 * Met le numéro de port dans la variable après le chargement de la config
 */
public void OnConfigsExecuted()
{
    if (port < 0)
        port = GetConVarInt(FindConVar("hostport"));
}

/**
 * Lorsqu’une personne se connecte, vérifie s’il peut se connecter.
 * Si oui, la met dans la bonne équipe, sinon la kick.
 */
//public void OnClientAuthorized(int client, const char[] auth)
public void SetTeamPlayer(Event event, const char[] name, bool dontBroadcast)
{
    int client = GetClientOfUserId(event.GetInt("userid"));
    GetClientAuthId(client, AuthId_Steam2, clientId, sizeof(clientId));
    if (!strcmp(clientId, "BOT", true)) { return; }
    if (FindAdminByIdentity("steam", clientId) != INVALID_ADMIN_ID)
    {
        ChangeClientTeam(client, CS_TEAM_SPECTATOR);
        allId[nbAllId] = client;
        nbAllId++;
    }
    else 
    {
        bool allGood = GetClientAuthId(client, AuthId_SteamID64, clientId, sizeof(clientId));
        if (allGood)
        {
            allGood = false;
            int i = 0;
            while (!allGood && i < sizeof(teamCT))
            {
                if (!strcmp(teamCT[i], clientId, false))
                {
                    ChangeClientTeam(client, CS_TEAM_CT);
                    allGood = true;
                    allId[nbAllId] = client;
                    nbAllId++;
                }
                else if (!strcmp(teamT[i], clientId, false))
                {
                    ChangeClientTeam(client, CS_TEAM_T);
                    allGood = true;
                    allId[nbAllId] = client;
                    nbAllId++;
                }
                i++;
            }
            if (!allGood)
            {
                KickClient(client, "Vous n’êtes pas autorisé à suivre / jouer \
                        sur ce serveur");
            }
            else
                CS_RespawnPlayer(client);
        }
    }
}

/**
 * Commande pour enregistrer les équipes:
 * !team ct NomEquipe id1 id2 id3 id4 id5
 */
public Action SetTeam(int args)
{
    char arg[128];
    GetCmdArg(1, arg, sizeof(arg));
    int team = (!strcmp(arg, "ct", false) ? 1 : 2);
    GetCmdArg(2, arg, sizeof(arg));
    if (team == 1)
        ServerCommand("mp_teamname_1 %s", arg)
    else
        ServerCommand("mp_teamname_2 %s", arg)

    if (args == 7)
    {
        for(int i = 3; i <= args; i++)
        {
            GetCmdArg(i, arg, sizeof(arg));
            if (team == 1)
                teamCT[i - 3] = arg;
            else
                teamT[i - 3] = arg;
        }
    }
    else
    {
        PrintToServer("Erreur, pas assez d’args");
    }

    return Plugin_Handled;
}

/**
 * TODO: À supprimer
 */
public void OnMapVoteStarted()
{
    // TODO kick tout le monde
    PrintToServer("======= FIN ======");
    for (int i = 0; i < nbAllId; i++)
    {
        PrintToServer("On kick %d.", allId[i]);
        if (IsClientInGame(allId[i])) {
            PrintToServer("NUUUUUUUL");
            KickClient(allId[i], "Le match est fini.");
        }
        allId[i] = 0;
    }
    ServeurLibre();
    nbAllId = 0;
    /* kick tout le monde */
}

/**
 * Envoie une requete POST au bot pour lui indiquer que la partie est finie
 * et que le serveur est libre.
 */
public void ServeurLibre()
{
    /*
    for (int i = 0; i < sizeof(teamCT); i++)
    {
        teamCT[i] = "";
        teamT[i] = "";
    }
    */
    // requete post pour match fini et serveur libre
    Handle socket = SocketCreate(SOCKET_TCP, OnSocketError);
    SocketConnect(socket, SocketEnvoieVictoire, OnSocketReceive, OnSocketDisconnected, MY_SOCKET_IP, MY_SOCKET_PORT);
}

/**
 * Envoie une requete POST au bot avec les nouveaux scores 
 */
public void UpdateScoreBoard(Event event, const char[] name, bool dontBroadcast)
{
    // request post avec les scores des 2 équipes
    Handle socket = SocketCreate(SOCKET_TCP, OnSocketError);
    SocketConnect(socket, SocketUpdateScore, OnSocketReceive, OnSocketDisconnected, MY_SOCKET_IP, MY_SOCKET_PORT);
}

/**
 * Commande de tests pour envoyant une requete avec le socket.
 */
public Action TestSocket(int args)
{
    PrintToServer("envoie socket");
    Handle socket = SocketCreate(SOCKET_TCP, OnSocketError);
    SocketConnect(socket, SocketUpdateScore, OnSocketReceive, OnSocketDisconnected, MY_SOCKET_IP, MY_SOCKET_PORT);
    return Plugin_Handled;
}

/**
 * Commande de tests pour envoyant une requete avec le socket.
 */
public Action TestSocketA(int args)
{
    Handle socket = SocketCreate(SOCKET_TCP, OnSocketError);
    SocketConnect(socket, SocketEnvoieVictoire, OnSocketReceive, OnSocketDisconnected, MY_SOCKET_IP, MY_SOCKET_PORT);
    return Plugin_Handled;
}

/**
 * Socket envoyant le score à la fin du round
 */
public void SocketUpdateScore(Handle socket, any arg)
{
    char requestStr[1024];
    char json[64];
    FormatEx(json, sizeof(json), "{\"port\": %d, \"ct\": %d, \"t\": %d}", 
        port, CS_GetTeamScore(CS_TEAM_CT), CS_GetTeamScore(CS_TEAM_T));
    FormatEx(
        requestStr,
        sizeof(requestStr),
        "POST /api/csgo/updatescore HTTP/1.1\r\n\
        Content-Type: application/json\r\n\
        Content-Length: %d\r\n\r\n%s", strlen(json), json
    );
    SocketSend(socket, requestStr, sizeof(requestStr));
    SocketDisconnect(socket);
    CloseHandle(socket);
}

/**
 * Socket envoyant la requete indiquant la fin du match
 */
public void SocketEnvoieVictoire(Handle socket, any arg)
{
    char requestStr[1024];
    char json[64];
    FormatEx(json, sizeof(json), "{\"serverport\": %d, \"available\": true}", port);
    FormatEx(
        requestStr,
        sizeof(requestStr),
        "POST /api/csgo/matchend HTTP/1.1\r\n\
        Content-Type: application/json\r\n\
        Content-Length: %d\r\n\r\n%s", strlen(json), json
    );
    SocketSend(socket, requestStr, sizeof(requestStr));
    SocketDisconnect(socket);
    CloseHandle(socket);
}

/* Méthodes sockets universels */

public void OnSocketReceive(Handle socket, const char[] datas, const int data, any arg) {}

public OnSocketDisconnected(Handle socket, any arg)
{
    CloseHandle(socket);
}

public void OnSocketError(Socket socket, const int errorType, const int errorNum, any hFile) {
	PrintToServer("socket error %d (errno %d)", errorType, errorNum);
	CloseHandle(socket);
}