%% TODO: link the sock to the gen_server

-export([dial/2, start_server/2]).

-behavior(gen_server).
-export([start_link/2, dial/2, channelList/1, join/2, part/2]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, code_change/3, terminate/2]).

%% TODO: make this a gen_server
%% calls:

%% TODO: calls:

%% - dial(peer)

%% - write(channel, text)
%% - query remote channels

-record(state, {db, connections=#{}, channels=#{}, activeOut=#{}, activeIn=#{}}).

-record(state, {handler, db, connections=0, activeOut = #{}, activeIn= #{}}).

dial(Pid, Addr) ->
    [HostStr, PortStr] = string:split(Addr, ":"),
    Host = inet:getaddr(HostStr, inet),
    Port = list_to_integer(PortStr),
    gen_server:cast(Pid, {dialPeer, [Host, Port]}).

dial(Host, Port) ->
  {ok, Sock} = gen_tcp:connect(Host, Port, [binary, {packet, 0}]),
  io:format("Connection established (~p:~p)~n", [Host, Port]),
  [{binary, Bin}, _ ] = examples:post_request(),
  gen_tcp:send(Sock, Bin),
  timer:sleep(1000),
  [{binary, Bin2}, _ ] = examples:cancel_request(),
  gen_tcp:send(Sock, Bin2),
  timer:sleep(1000),
  [{binary, Bin3}, _ ] = examples:channel_time_range_request(),
  gen_tcp:send(Sock, Bin3),
  timer:sleep(1000),
  gen_tcp:close(Sock).

join(Pid, Chan) when is_list(Chan) ->
    gen_server:cast(Pid, {channelJoin, Chan}).

start_server(Host, Port) ->

part(Pid, Chan) when is_list(Chan) ->
    gen_server:cast(Pid, {channelPart, Chan}).
channelList(Pid) ->
    gen_server:call(Pid, {channelList}).
%%%%%%%%%%%%%%%%
%% gen_server %%
%%%%%%%%%%%%%%%%
%% {ok, P} = peer:start_link("localhost", 3133). peer:join(P, "default"). peer:channelList(P).
start_link(Host, Port) ->
    gen_server:start_link({local, cabalPeer}, peer, [{listener, [Host, Port]}], []).
init(Args) ->
    process_flag(trap_exit, true),
    [Host, Port] = proplists:get_value(listener, Args),

    % TODO: supervise this handler

    Handler = spawn(fun() -> handle_messages(State) end),
    server_loop(Handler, Lis).

    % TODO: supervise these processes
    Handler = spawn_link(fun() -> event_loop(State) end),
    ListenProc = spawn_link(fun() -> listen_loop(Handler, Lis) end),
    {ok, [{listenProc, ListenProc}, {eventLoop, Handler}]}.

server_loop(Handler, Lis) ->

handle_call({channelList}, From, State) ->
    EL = proplists:get_value(eventLoop, State),
    EL ! {channelList, From}, % reply via event loop
    {noreply, State}.
handle_cast({dialPeer, [Host, Port]}, State) ->
    {ok, Sock} = gen_tcp:connect(Host, Port, [binary, {packet, 0}]),
    io:format("Connection established (~p:~p)~n", [Host, Port]),
    EL = proplists:get_value(eventLoop, State),
    EL ! {newPeer, Sock},
    {noreply, State};
handle_cast({channelJoin, Chan}, State) ->
    io:format("joining ~p~n", [Chan]),
    EL = proplists:get_value(eventLoop, State),
    EL ! {channelJoin, Chan},
    {noreply, State};
handle_cast({channelPart, Chan}, State) ->
    io:format("leaving ~p~n", [Chan]),
    EL = proplists:get_value(eventLoop, State),
    EL ! {channelPart, Chan},
    {noreply, State};
handle_cast(Msg, State) ->
    io:format("Unexpected cast: ~p~n", [Msg]),
    {noreply, State}.
handle_info(Msg, State) ->
    io:format("Unexpected message: ~p~n", [Msg]),
    {noreply, State}.
terminate(TermReason, _State) ->
    io:format("terminating peer: ~p~n", [TermReason]),
    %% LisProc = proplists:get_value(listenProc, State),
    %% unlink(LisProc),
    %% EventLoopProc = proplists:get_value(eventLoop, State),
    %% unlink(EventLoopProc),
    ok.
code_change(_OldVsn, State, _Extra) ->
    %% no change planned. The functionm is there for the behaviour,
    %% but will not be used.
    {ok, State}.
%%%%%%%%%%%%%
%% private %%
%%%%%%%%%%%%%
listen_loop(Handler, Lis) ->

    % TODO: read docs of this linkage

    %% TODO: read docs of this linkage

    % init connection
    ReqId = send_channel_state_request(Sock, "#default", true),
    Handler ! {newOutRequest, ReqId, Sock},
    server_loop(Handler, Lis).

    Handler ! {newPeer, Sock},
    listen_loop(Handler, Lis).

  % read incoming messages
  case gen_tcp:recv(Conn, 0) of
    {ok, Data} ->
      {ok, Msgs} = wire:split_messages(Data),
          lists:foreach(fun(Chunk) ->
                                {ok, Msg} = wire:decode(Chunk),
                                Handler ! {incomingMsg, Conn, Msg}
                        end, Msgs),
          decode_loop(Handler, Conn);
    {error, closed} ->
      io:format("Connection closed ~p~n", [Conn])
  end.

    %% read incoming messages
    case gen_tcp:recv(Conn, 0) of
        {ok, Data} ->
            {ok, Msgs} = wire:split_messages(Data),
            EachMsg = fun(Chunk) ->
                              {ok, Msg} = wire:decode(Chunk),
                              Handler ! {incomingMsg, Conn, Msg}
                      end,
            lists:foreach(EachMsg, Msgs),
            decode_loop(Handler, Conn);
        {error, closed} ->
            io:format("Connection closed ~p~n", [Conn])
    end.

handle_messages(State = #state{activeOut = ActiveOut, activeIn = ActiveIn}) ->

event_loop(State = #state{activeOut = ActiveOut, activeIn = ActiveIn, connections = Peers, channels = Chans}) ->

        {newPeer, Peer} ->
            EachChan = fun(Chan, AccActiveOut) ->
                               ReqId = send_channel_state_request(Peer, Chan, true),
                               {ReqId, maps:put(ReqId, {sent, Peer}, AccActiveOut)}
                       end,
            {ChanReqs, NewActiveOut} = lists:mapfoldl(EachChan, ActiveOut, maps:keys(Chans)),
            NewConns = maps:put(Peer, ChanReqs, Peers),
            NewState = State#state{connections = NewConns, activeOut = NewActiveOut},
            event_loop(NewState);
        {channelJoin, Chan} ->
            case maps:is_key(Chan, Chans) of
                true -> % already joined
                    event_loop(State);
                false ->
                    %% send requests to each connection
                    EachPeer = fun(Peer, AccActives) ->
                                       %% TODO: Post = posts:encode_join(Key, Chan),
                                       {ok, ReqId} = send_channel_state_request(Peer, Chan, true),
                                       {ReqId, maps:put(ReqId, {sent, Peer}, AccActives)}
                               end,
                    {ReqIds, NewActiveOut} = lists:mapfoldl(EachPeer, ActiveOut, maps:keys(Peers)),
                    NewChans = maps:put(Chan, ReqIds, Chans),
                    NewState = State#state{channels =  NewChans, activeOut = NewActiveOut},
                    event_loop(NewState)
            end;
        {channelPart, Chan} ->
            case maps:is_key(Chan, Chans) of
                false -> % not even joined
                    event_loop(State);
                true ->
                    {ReqIds, NewChans} = maps:take(Chan, Chans),
                    EachReq = fun(ReqId, AccActives) ->
                                      %% TODO: Post = posts:encode_part(Key, Chan),
                                      {{sent, Conn}, NewActive} = maps:take(ReqId, AccActives),
                                      CancelReqId = send_cancel_request(Conn, ReqId),
                                      {ok, maps:put(CancelReqId, {sent, Conn}, NewActive)}
                              end,
                    {_OKs, NewActiveOut} = lists:mapfoldl(EachReq, ActiveOut, ReqIds),
                    NewState = State#state{channels = NewChans, activeOut = NewActiveOut},
                    event_loop(NewState)
            end;
        {channelList, From} ->
            gen_server:reply(From, maps:keys(Chans)),
            event_loop(State);

            handle_messages(NewState);
        {incomingMsg, Conn, Msg} ->

            event_loop(NewState);
        {incomingMsg, Peer, Msg} ->

            io:format("DEBUG new message Type:~p - Body:~p~n", [MsgType, Body]),

            io:format("[DEBUG] new message Type:~p - Body:~p~n", [MsgType, Body]),

                            %% TODO: currently we we request all the hashes all the time.
                            %% this needs to be deduped and spread out across conns.

                            PostReqId = send_post_request(Conn, Hashes),
                            UpdatedOut = maps:put(PostReqId, {sent, Conn},  ActiveOut),

                            PostReqId = send_post_request(Peer, Hashes),
                            UpdatedOut = maps:put(PostReqId, {sent, Peer},  ActiveOut),

                            handle_messages(NewState);

                            event_loop(NewState);

                            [io:format("got post reply:~n~p~n", [posts:decode(P)]) || P <- Posts]

                            [io:format("[TEMP] got post reply:~n~p~n", [posts:decode(P)]) || P <- Posts]

                    %send_cancel_request(Conn, ReqId),
                    %NewState = State#state{activeOut = maps:remove(ReqId, ActiveOut)},
                    %handle_messages(NewState);

                    NewState = State#state{activeIn = maps:put(ReqId, {received, Conn, Msg}, ActiveIn)},
                    io:format("Received incoming RequestId:~p from ~p~n", [ReqIdStr, Conn]),
                    handle_messages(NewState)

                    NewState = State#state{activeIn = maps:put(ReqId, {received, Peer, Msg}, ActiveIn)},
                    io:format("Received incoming RequestId:~p from ~p~n", [ReqIdStr, Peer]),
                    event_loop(NewState)

            handle_messages(State)

            event_loop(State)

% H = spawn(fun() -> peer:start_server('localhost', 13333) end).

    gen_server:start_link({local, cabaldb}, ?MODULE, [{dbPath, DbPath}], []).

    gen_server:start_link({local, cabalDatabase}, ?MODULE, [{dbPath, DbPath}], []).