-module(server).
-export([start/0, start/1, stop/1, run/2, client_register/2]).

%% Inclusion des librairies tierces
-include("datas.hrl").

%% Lancement du serveur
start() -> start(?default_port).
start(Port) ->
    database:start(),
    Listener =
        case gen_tcp:listen(Port, [{packet, 0}, {active, false}, {reuseaddr, true}]) of
            {ok, ListenSocket} ->
                %% Serveur lancé
                io:format("Host Launched on: ~p~n", [Port]),
                ListenSocket;
            {error, Raison} ->
                %% Serveur impossible à lancer
                io:format("Host Running failed on ~p: [~p]~n", [Port, Raison]),
                exit(Raison)
        end,
    %% Procédure de lancement du serveur
    Pollable = database:list_pollable(),
    spawn(?MODULE, run, [Listener, Pollable]).

%% Procédure d'arrêt du serveur
stop(Pid) ->
    database:stop(),
    Pid ! {stop},
    ok.

%% Interpretation du serveur
run(ListenSocket, Pollable) ->
    process_flag(trap_exit, true),
    loop(ListenSocket, Pollable).

%% Boucle d'exécution du serveur
loop(ListenSocket, Pollable) ->
    %% Boite à message concurrente
    receive
        {stop} ->
            %% Fermeture du serveur
            io:format("Host has been stopped~n", []),
            exit(normal);
        {'EXIT', Pid, Raison} ->
            %% Destruction de la session du membre
            io:format("Disconnection of a client~n", [])
        %% Repos
        after 100 -> timeout
    end,
    %% Traitement des entrées
    case gen_tcp:accept(ListenSocket, 100) of
        {ok, Socket} ->
            case serverActive() of
                false ->
                    io:format("Not in Election Interval~n", []),
                    gen_tcp:send(Socket, "Not in Election Interval~n"),
                    gen_tcp:close(Socket);
                true ->
                    %% Réception des messages envoyés
                    io:format("New connection~n", []),
                    PClientID = spawn_link(?MODULE, client_register, [Socket, Pollable]),
                    gen_tcp:controlling_process(Socket, PClientID)
            end,
            run(ListenSocket, Pollable);
        %% Timer de repos au serveur
        {error, timeout} ->
            %% Récursion
            run(ListenSocket, Pollable)
    end.

%% Gestion des clients connectés
client_register(Socket, Pollable) ->
    case gen_tcp:recv(Socket, 0) of
        {ok, Data} ->
            %% Gestion de la connexion
            Tokenize = string:tokens(Data, " "),
            case Tokenize of
                [Hash, Vote] ->
                    {CanVote, []} = database:is_client(string:to_integer(Hash)),
                    IntVote = string:to_integer(Vote),
                    case CanVote of
                        error ->
                            gen_tcp:send(Socket, "Not valid Hashkey~n"),
                            io:format("Vote fail~s~n", [Hash]),
                            gen_tcp:close(Socket);
                        Value ->
                            database:insert_poll(IntVote),
                            database:unfold_client(Value),
                            gen_tcp:send(Socket, "Vote Executed~n"),
                            io:format("Vote saved~n", []),
                            gen_tcp:close(Socket)

                    end;
                _ ->
                    gen_tcp:send(Socket, "Not valid protocol~n"),
                    gen_tcp:close(Socket)
            end,
            %% Récursion du client
            client_register(Socket, Pollable);
        {error, closed} ->
            gen_tcp:close(Socket)
    end.

%% Interrogation sur l'activité du serveur
serverActive() ->
    {CurrY, CurrM, CurrD} = date(),
    {BeginY, BeginM, BeginD} = ?date_begin,
    {EndY, EndM, EndD} = ?date_end,
    CurrentTime = (CurrY*10000) + (CurrM*100) + CurrD,
    BeginTime = (BeginY*10000) + (BeginM*100) + BeginD,
    EndTime = (EndY*10000) + (EndM*100) + EndD,
    (CurrentTime > BeginTime) and (CurrentTime < EndTime).