-module(rps).
-import(rps3, [get_rules/0]).
-export([
    go/0,
    lobby/0, counter/0, printer/0,
    fool/0, copycat/0, gambler/0]).
-define(BOTS, [fool, copycat, gambler]).
go() ->
    register(lobby, spawn_link(?MODULE, lobby, [])),
    register(counter, spawn_link(?MODULE, counter, [])),
    register(printer, spawn_link(?MODULE, printer, [])),
    [spawn_link(?MODULE, Bot, []) || Bot <- ?BOTS].
lobby() ->
    lobby([]).
lobby(Players) when length(Players) =:= length(?BOTS) ->
    Room = spawn_link(rps_room, room, [Players]),
    lists:foreach(fun(Player) -> Player ! {room, Room} end, Players),
    lobby([]);
lobby(Players) ->
    receive
        {join, Who} ->
            lobby([Who|Players])
    end.
counter() ->
    counter(0, 0, dict:new(), dict:new()).
counter(Plays, Draws, Wins, Hands) ->
    receive
        {draw, _} ->
            counter(Plays + 1, Draws + 1, Wins, Hands);
        {winner, {Hand, Winner}} ->
            counter(Plays + 1, Draws,
                    dict:update_counter(Winner, 1, Wins),
                    dict:update_counter(Hand, 1, Hands));
        {sendstats, Pid} ->
            Pid ! {stats, {
                     plays, Plays,
                     draws, Draws,
                     wins, dict:to_list(Wins),
                     hands, dict:to_list(Hands)}},
            counter(Plays, Draws, Wins, Hands)
    end.
printer() ->
    receive
        {stats, Stats} ->
            io:format("Stats: ~w.~n", [Stats])
    after 1000 ->
            counter ! {sendstats, self()}
    end,
    printer().
fool() ->
    lobby ! {join, self()},
    fool(joined).
fool(joined) ->
    receive
        {room, Room} ->
            random:seed(now()),
            fool(Room)
    end;
fool(Room) ->
    receive
        start ->
            Hand = lists:nth(random:uniform(length(get_rules())), get_rules()),
            Room ! {Hand, self()},
            fool(Room);
        {winner, _} ->
            fool(Room)
    end.
copycat() ->
    lobby ! {join, self()},
    copycat(joined).
copycat(joined) ->
    receive
        {room, Room} ->
            copycat(Room, hd(get_rules()))
    end.
copycat(Room, Hand) ->
    receive
        start ->
            Room ! {Hand, self()},
            copycat(Room, Hand);
        {winner, {NewHand, _}} ->
            copycat(Room, NewHand)
    end.
gambler() ->
    lobby ! {join, self()},
    gambler(joined).
gambler(joined) ->
    receive
        {room, Room} ->
            Wins = dict:from_list([{C, 0} || C <- get_rules()]),
            gambler(Room, Wins)
    end.
gambler(Room, Wins) ->
    receive
        start ->
            F = fun({_, A}, {_, B}) -> A =< B end,
            {Hand, _} = hd(lists:sort(F, dict:to_list(Wins))),
            Room ! {Hand, self()},
            gambler(Room, Wins);
        {winner, {Hand, _}} ->
            gambler(Room, dict:update_counter(Hand, 1, Wins))
    end.