connect_two_peers_test_x() ->

connect_two_peers_test() ->

                         {AlfiName, AlfiWhen} = maps:get(PubAlfi, Members),

                         {AlfiName, AlfiWhen, false} = maps:get(PubAlfi, Members),

                         {BertName, BertWhen} = maps:get(PubBert, Members),

                         {BertName, BertWhen, false} = maps:get(PubBert, Members),

    ok = peer:stop(Alfi),
    ok = peer:stop(Bert).
chat_test() ->
    [A, B] = [make_test_args() || _ <- lists:seq(1,2)],
    {ok, Alfi} = peer:start_link(A),
    {ok, Bert} = peer:start_link(B),

    %?assert(false),

    {ok, PubAlfi} = peer:node_public_key(Alfi),
    {ok, PubBert} = peer:node_public_key(Bert),
    NickAlfi =  "Alfi",
    NickBert = "Not ernie!!",
    ok = peer:set_nick(Alfi, NickAlfi),
    ok = peer:set_nick(Bert, NickBert),
    C = "test",
    peer:join(Alfi, C),
    peer:join(Bert, C),
    T1 = "someone here?",
    T2 = "is this thing on?",
    ok = peer:write(Alfi, C, T1),
    timer:sleep(500), %% enforce ordering
    ok = peer:write(Bert, C, T2),
    {ok, PeerAddr} = peer:node_addr(Bert),
    ok = peer:dial(Alfi, PeerAddr),
    timer:sleep(1000),
    Check = fun(Peer) ->
                    {ok, {Texts, Users}} = peer:read(Peer, C),
                    [{UserIdAlfi, _, T1}, {UserIdBert, _, T2}] =  Texts,
                    {AlfiInfo, UsersSansAlfi} = maps:take(UserIdAlfi, Users),
                    ?assertEqual({NickAlfi, PubAlfi}, AlfiInfo),
                    {BertInfo, #{}} = maps:take(UserIdBert, UsersSansAlfi),
                    ?assertEqual({NickBert, PubBert}, BertInfo)
            end,
    lists:foreach(Check, [Alfi, Bert]),
    %% that's nice but do we also transmit posts while connected?
    ok = peer:write(Alfi, C, "ohai! o/"),
    timer:sleep(500),
    {ok, {Texts, _}} = peer:read(Bert, C),
    ?assertEqual(3, length(Texts)),
    ok = peer:write(Bert, C, "nice to meet you!"),
    timer:sleep(250),
    {ok, {Texts2, _}} = peer:read(Alfi, C),
    ?assertEqual(4, length(Texts2)),

%% TODO: add tests for:
%% - leaving and joining again
%% - reading messages after having left (channel member still listed but as left)

                          %WantBin = hex:hexstr_to_bin(Want),

                          %?assertEqual(WantBin, Got)

-export([channels_joined/1, channels_known/1, channel_state/2, join/2, leave/2]).
-export([set_topic/3, set_nick/2, write/3]).

-export([channels_joined/1, channels_known/1, channel_members/2, join/2, leave/2]).
-export([set_topic/3, set_nick/2, read/2, write/3]).

channel_state(Pid, Chan) ->
    gen_server:call(Pid, {channelsState, Chan}).

channel_members(Pid, Chan) ->
    gen_server:call(Pid, {channelsMembers, Chan}).

read(Pid, Chan) ->
    gen_server:call(Pid, {readTextsFromChannel, Chan}).

handle_call({readTextsFromChannel, Chan}, From, State) ->
    EL = proplists:get_value(eventLoop, State),
    EL ! {readTextsFromChannel, From, Chan}, % reply via event loop
    {noreply, State};

handle_call({channelsState, Chan}, From, State) ->

handle_call({channelsMembers, Chan}, From, State) ->

    EL ! {channelsState, From, Chan}, % reply via event loop

    EL ! {channelsMembers, From, Chan}, % reply via event loop

            %% TODO: get most recent links state for channel
            Links = [],

            {ok, Links} = db:get_channel_heads(Db, null),

            gen_server:reply(From, ok),

            gen_server:reply(From, ok),

        {readTextsFromChannel, From, Chan} ->
            {ok, Texts} = db:get_texts_for_channel(Db, Chan),
            gen_server:reply(From, {ok, Texts}),
            event_loop(State);

                false -> % already joined

                false ->

                    %% TODO: get most recent links state for channel
                    Links = [],

                    {ok, Links} = db:get_channel_heads(Db, Chan),

                    SentPeers = lists:foldl(fun({Direction, ReqId, Peer}, AccPeers) ->
                                                    case Direction of
                                                        received ->
                                                            {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                                                            case proplists:get_value(type, Header) of
                                                                4 ->
                                                                    {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                                                                    update_peer_sent(AccPeers, Peer, Size);
                                                                _ -> AccPeers % ignored
                                                            end;
                                                        sent ->
                                                            AccPeers
                                                    end
                                  end, Peers, maps:get(Chan, Chans)),

                    %% find incoming channel time range (type:4) requests which want this post
                    F = fun({Direction, ReqId, Peer}, AccPeers) ->
                                case Direction of
                                    received ->
                                        {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                                        case proplists:get_value(msgType, Header) of
                                            4 ->
                                                {ok, {_, _, Size}}
                                                    = send_hash_response(Peer, ReqId, [PostHash]),
                                                update_peer_sent(AccPeers, Peer, Size);
                                            _ -> AccPeers
                                        end;
                                    sent -> AccPeers
                                end
                        end,
                    SentPeers = lists:foldl(F, Peers, maps:get(Chan, Chans)),
                    io:format("[Wrote] #~p: ~p~n", [Chan, Text]),

                     %% TODO: get most recent links state for channel
                    Links = [],

                    {ok, Links} = db:get_channel_heads(Db, Chan),

        {channelsState, From, Chan} ->

        {channelsMembers, From, Chan} ->

                    Result = db:get_channel_state(Db, Chan),

                    Result = db:get_channel_members(Db, Chan),

                    %% TODO: get most recent links state for channel
                    Links = [],

                    {ok, Links} = db:get_channel_heads(Db, Chan),

                    %% TODO: get most recent links state for channel
                    Links = [],

                    {ok, Links} = db:get_channel_heads(Db, Chan),

    io:format("[DEBUG] new message ReqId:~p Type:~p - IsActiveOut ~p - Size:~p~n",
              [ReqIdStr, MsgType, IsActiveOut, MsgSize]),

    io:format("[DEBUG] incoming message  ReqId:~p  Type:~p  Size:~p\tIsActiveOut:~p~n",
              [ReqIdStr, MsgType, MsgSize, IsActiveOut]),

            io:format("[Peer:~p] Received reply to ~p!~n", [Peer, ReqIdStr]),

            %% io:format("[Peer:~p] Received reply to ~p!~n", [Peer, ReqIdStr]),

                            [Start, End, Limit] = [proplists:get_value(F, Body) ||

                            Params = [proplists:get_value(F, Body) ||

                            io:format("[DEBUG] with params: S:~p - E:~p - L:~p ~n",Params),
                            [Start, End, Limit] = Params,

                            io:format("[DEBUG] Received incoming state req for ~p from ~p~n",
                                      [RequestedChan, Peer]),
                            {ok, Hashes} = db:get_channel_heads(Db, RequestedChan),

                          %%  io:format("[DEBUG] Received incoming state req for ~p from ~p~n",
                          %%            [RequestedChan, Peer]),
                            {ok, Hashes} = db:get_channel_state(Db, RequestedChan),

-export([has_post/2, get_text_hashes_by_time_range/5]).
-export([channels_join/2, channels_leave/2, channels_list/1, get_channel_heads/2, get_channel_state/2]).

-export([has_post/2, get_text_hashes_by_time_range/5, get_texts_for_channel/2]).
-export([channels_join/2, channels_leave/2, channels_list/1]).
-export([get_channel_state/2, get_channel_members/2, get_channel_heads/2]).

%% TODO: time windows and limit
get_texts_for_channel(Db, Chan) ->
    gen_server:call(Db, {textsForChannel, Chan}).

                    0 -> 66269664000;

                    0 -> 6626966400000;

%% returns a map of the members
get_channel_members(Db, Chan) ->
    gen_server:call(Db, {channelsMembers, Chan}).

%% helps with channel state requests

%% helps with creating links for new posts

handle_call({textsForChannel, Chan}, _From, [{sql, Db}, _] = State) ->
    Qry = "SELECT user_id, timestamp, text from posts where channel = ? and type = 0 order by timestamp asc",
    QryChan = {blob, list_to_binary(Chan)},
    [{columns, ["user_id", "timestamp", "text"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [QryChan]), %%, Start, End, Limit]),
    %% map rows and add user information
    QryUser = "SELECT name, public_key FROM users where id = ?",
    F = fun({UserId, Ts, {blob, TextBin}}, {Texts, Users}) ->
                NewUsers = case maps:is_key(UserId, Users) of
                               true -> Users;
                               false ->
                                   [{columns, ["name", "public_key"]},
                                    {rows, [{NameBin, {blob, PubKey}}]}] = sqlite3:sql_exec(Db, QryUser, [UserId]),
                                   Name = unicode:characters_to_list(NameBin),
                                   Users#{UserId => {Name, PubKey}}
                           end,
                Text = unicode:characters_to_list(TextBin),
                {Texts ++ [{UserId, Ts, Text}], NewUsers}
        end,
    Result = lists:foldl(F, {[], #{}}, Rows),
    {reply, {ok, Result}, State};

%% TODO: obviously incomplete

%% TODO: add tests

    Qry = "SELECT hash, user_id from posts where channel = ? and type > 1 order by timestamp desc",

    Qry = "SELECT DISTINCT source FROM links "
        ++ "WHERE source NOT IN ("
        ++ "  SELECT DISTINCT parent FROM links"
        ++ "    WHERE channel = ? or channel is null)",
    QryChan = case Chan of
                  null -> null;
                  _ when is_list(Chan) -> {blob, list_to_binary(Chan)}
              end,
    [{columns, ["source"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [QryChan]),
    Result = [Hash || {{blob, Hash}} <- Rows],
    {reply, {ok, Result}, State};
handle_call({channelsState, Chan}, _, [{sql, Db}, _] = State) ->
    Qry = "SELECT hash, user_id from posts where channel = ? and type > 2 order by timestamp",

    InfoPostQry = "SELECT hash from posts where user_id = ? and type = 2",

    %% add info posts for all users involved
    InfoPostQry = "SELECT hash from posts where user_id = ? and type = 2 order by timestamp desc limit 1",

                                          [{{blob, H}}] ->
                                              sets:add_element(H, Acc);
                                          [] ->
                                              Acc

                                          [{{blob, H}}] -> sets:add_element(H, Acc);
                                          [] -> Acc

handle_call({channelsState, Chan}, _, [{sql, Db}, _] = State) ->

%% TODO: add people that left (might have messages from them)
handle_call({channelsMembers, Chan}, _, [{sql, Db}, _] = State) ->

    MembersQry = "SELECT users.name as name, users.public_key as pub_key, posts.timestamp as timestamp "
        ++ "FROM channel_members "
        ++ "JOIN posts ON channel_members.post_hash = posts.hash "
        ++ "JOIN users ON channel_members.user_id = users.id "
        ++ "WHERE channel_members.channel = ?",

    MembersQry = "SELECT u.name as name, u.public_key as pub_key, p.timestamp as timestamp, p.type as type "
        ++ "FROM channel_members m "
        ++ "JOIN posts p ON m.last_hash = p.hash "
        ++ "JOIN users u ON m.user_id = u.id "
        ++ "WHERE m.channel = ?",

    [ {columns, ["name", "pub_key", "timestamp"]}

    [ {columns, ["name", "pub_key", "timestamp", "type"]}

                            {NameBin, {blob, PubKey}, When} = Row,

                            {NameBin, {blob, PubKey}, When, PostType} = Row,

                            Acc#{PubKey => {Name, When}}

                            HasLeft = case PostType of
                                          4 -> false;
                                          5 -> true
                                      end,
                            Acc#{PubKey => {Name, When, HasLeft}}

            Res = sqlite3:write(Db, channel_members, [ {channel, Chan}
                                                     , {user_id, UserId}
                                                     , {post_hash, {blob, Hash}}]),

            Qry = "INSERT INTO channel_members(channel, user_id, last_hash) VALUES (?, ?, ?) "
                ++ "ON CONFLICT(user_id) DO UPDATE SET last_hash=excluded.last_hash",
            Res = sqlite3:sql_exec(Db, Qry, [ Chan, UserId, {blob, Hash}]),

            Qry = "DELETE FROM channel_members where channel = ? and user_id = ?",
            ok = sqlite3:sql_exec(Db, Qry, [Chan, UserId]),

            Qry = "UPDATE channel_members set last_hash = ? where channel = ? and user_id = ?",
            ok = sqlite3:sql_exec(Db, Qry, [{blob, Hash}, Chan, UserId]),

               channel_members => [ColId, {channel, text, not_null}, {user_id, integer, not_null}, {post_hash, blob, not_null}],

               channel_members => [ColId
                                  , {channel, text, not_null}
                                  , {user_id, integer, [unique, not_null]}
                                  , {last_hash, blob, not_null}
                                  ],