encode_test() ->

encode_test_test() ->

encode_info_test() ->
    TestKp = enacl:sign_keypair(),
    Name =  "元気な子",
    Post = posts:encode(TestKp, [], {info, {name, Name}}),
    Decoded = posts:decode(Post),
    [
     [ {public_key, _Public}
     , {links, _Links}
     , {type, 2}
     , {timestamp, _TimeStamp}
     , {hash, _Hash}
     ],
     [ {infos, #{<<"name">> := BinName}}
     ]
    ] = Decoded,
    GotName = unicode:characters_to_list(BinName),
    ?assertEqual(Name, GotName).

    {ok, Chans} = peer:channel_list(P),

    {ok, Chans} = peer:channels_joined(P),

    {ok, []} = peer:channel_list(P),

    {ok, []} = peer:channels_joined(P),

    {ok, ["default"]} = peer:channel_list(P),

    {ok, ["default"]} = peer:channels_joined(P),

    {ok, []} = peer:channel_list(P),

    {ok, []} = peer:channels_joined(P),

connect_two_peers_test() ->

connect_two_peers_test_x() ->

make_test_args() ->
    S = string:chomp(os:cmd("mktemp --tmpdir -d caberl-peer-XXXXX")),
    ?debugFmt("~nUsing Storage: ~p~n", [S]),
    [ {listener, ["localhost", 0]}
    , {storage, S}].

set_nick_and_topic_test() ->
    [A, B] = [make_test_args() || _ <- lists:seq(1,2)],
    {ok, Alfi} = peer:start_link(A),
    {ok, Bert} = peer:start_link(B),
    {ok, PubAlfi} = peer:node_public_key(Alfi),
    {ok, PubBert} = peer:node_public_key(Bert),
    ok = peer:set_nick(Alfi, "Alfi"),
    ok = peer:set_nick(Bert, "Not Ernie!"),
    C = "test",
    peer:join(Alfi, C),
    peer:join(Bert, C),
    T =  "the mega testing channel",
    ok = peer:set_topic(Alfi, C, T),
    %%{ok, PeerAddr} = peer:node_addr(Alfi),
    %%ok = peer:dial(Bert, PeerAddr),
    {ok, PeerAddr} = peer:node_addr(Bert),
    ok = peer:dial(Alfi, PeerAddr),
    timer:sleep(1000),
    CheckState = fun(Peer) ->
                         {ok, CState} = peer:channel_state(Peer, C),
                         ?assertEqual(T, proplists:get_value(topic, CState)),
                         Members = proplists:get_value(members, CState),
                         ?assertEqual(2, maps:size(Members)),
                         {AlfiName, AlfiWhen} = maps:get(PubAlfi, Members),
                         ?assertEqual("Alfi", AlfiName),
                         ?assert(AlfiWhen > 0),
                         {BertName, BertWhen} = maps:get(PubBert, Members),
                         ?assertEqual("Not Ernie!", BertName),
                         ?assert(BertWhen > 0)
                 end,
    lists:foreach(CheckState, [Alfi, Bert]),

    %?assert(false),
    ok = peer:stop(Alfi),
    ok = peer:stop(Bert).

%%%%%
%% helpers
%%%%%
make_test_args() ->
    S = string:chomp(os:cmd("mktemp --tmpdir -d caberl-peer-XXXXX")),
    ?debugFmt("~nUsing Storage: ~p~n", [S]),
    [ {listener, ["localhost", 0]}
    , {storage, S}].

    channel text,

    -- foreign key(parent) references posts(hash)

    -- foreign key(parent) references posts(hash),

% TODO: delete, info, topic

% TODO: delete

encode_body({join, Chan}) ->

encode_body({delete, Hashes}) ->
    NumHashes = wire:encode_varint(length(Hashes)),
    lists:foreach(fun(H) -> 32 = length(H) end, Hashes),
    {1, iolist_to_binary([1, NumHashes, Hashes])};
encode_body({info, {name, Name}}) ->
    NameBin = unicode:characters_to_binary(Name),
    NameLen = wire:encode_varint(byte_size(NameBin)),
    {2, iolist_to_binary([4, <<"name">>, NameLen, NameBin, 0])};
encode_body({topic, Chan, Topic}) ->

    {4, iolist_to_binary([ChanLen, ChanBin])};
encode_body({leave, Chan}) ->

    TopicData = case length(Topic) of
                    0 -> [0];
                    _ ->
                        TopicBin = unicode:characters_to_binary(Topic),
                        TopicLen = wire:encode_varint(byte_size(TopicBin)),
                        [TopicLen, TopicBin]
                end,
    {3, iolist_to_binary([ChanLen, ChanBin] ++ TopicData)};
encode_body({JL, Chan}) when JL =:= join; JL =:= leave ->
    TypeCode = case JL of
                   join -> 4;
                   leave -> 5
               end,

    {5, iolist_to_binary([ChanLen, ChanBin])}.

    {TypeCode, iolist_to_binary([ChanLen, ChanBin])}.

-export([node_addr/1, dial/2, peer_list/1, channel_list/1, join/2, leave/2, write/3]).

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

%% - list connections
%% - write(channel, text)

node_public_key(Pid) ->
    gen_server:call(Pid, {nodePubKey}).

channel_list(Pid) ->

channels_joined(Pid) ->

channels_known(_Pid) ->
    {error, todo}.
    %% gen_server:call(Pid, {channelsQueryKnown}).
channel_state(Pid, Chan) ->
    gen_server:call(Pid, {channelsState, Chan}).
set_topic(Pid, Chan, Topic) ->
    gen_server:call(Pid, {channelsSetTopic, Chan, Topic}).
set_nick(Pid, Nick) ->
    gen_server:call(Pid, {setOwnNick, Nick}).

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

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

        {nodePubKey, From} ->
            PubKey = maps:get(public, KeyPair),
            gen_server:reply(From, {ok, PubKey}),
            event_loop(State);

        {setOwnNick, From, Nick} ->
            %% TODO: get most recent links state for channel
            Links = [],
            Bin = posts:encode(KeyPair, Links, {info, {name, Nick}}),
            {ok, _, PostHash} = db:save_post(Db, Bin),
            %% sent out to (all?) open channel state requests
            F = fun(ReqId, {Peer, [Header, _]}, AccPeers) ->
                        case proplists:get_value(type, Header) of
                            5 ->
                                {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                                update_peer_sent(AccPeers, Peer, Size);
                            _ -> AccPeers
                        end
                end,
            SentPeers = maps:fold(F, Peers, ActiveIn),
            gen_server:reply(From, ok),
            event_loop(State#state{peers = SentPeers});

                    SentPeers = lists:foldl(fun({received, ReqId, Peer}, AccPeers) ->

                    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)),
                    gen_server:reply(From, ok),
                    event_loop(State#state{peers = SentPeers})
                end;
        {channelsSetTopic, From, Chan, Topic} ->
            case maps:is_key(Chan, Chans) of
                false -> % already joined
                    gen_server:reply(From, {error, notInChannel}),
                    event_loop(State);
                true ->
                     %% TODO: get most recent links state for channel
                    Links = [],
                    Bin = posts:encode(KeyPair, Links, {topic, Chan, Topic}),
                    {ok, _, PostHash} = db:save_post(Db, Bin),
                     SentPeers = lists:foldl(fun({received, ReqId, Peer}, AccPeers) ->

                                              _ -> AccPeers; % ignored

                                                  update_peer_sent(AccPeers, Peer, Size)

                                                        update_peer_sent(AccPeers, Peer, Size);
                                              _ -> AccPeers % ignored

        {channelsState, From, Chan} ->
            case maps:is_key(Chan, Chans) of
                false -> % already joined
                    gen_server:reply(From, {error, notInChannel});
                true ->
                    Result = db:get_channel_state(Db, Chan),
                    gen_server:reply(From, Result)
            end,
            event_loop(State);

                    [io:format("[TEMP] got post reply:~n~p~n", [posts:decode(P)]) || P <- Posts],
                    [{ok, _, _} = db:save_post(Db, P) || P <- Posts],

                    FilterUnknownPosts = fun(Bin) ->
                                                 %% TODO: avoid double decode by pushing this into the db module
                                                 [NewHeader, _] = posts:decode(Bin),
                                                 H = proplists:get_value(hash, NewHeader),
                                                 HasNot = not db:has_post(Db, H),
                                                 io:format("[TEMP] got new(~p) post reply:~n~p~n", [HasNot, NewHeader]),
                                                 HasNot
                                         end,
                    NewPosts = lists:filter(FilterUnknownPosts, Posts),
                    [{ok, _, _} = db:save_post(Db, P) || P <- NewPosts],

                            {ok, Hashes} = db:get_channel_state(Db, RequestedChan),

                            {ok, Hashes} = db:get_channel_heads(Db, RequestedChan),

-export([channels_join/2, channels_leave/2, channels_list/1, get_channel_state/2]).

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

has_post(Db, Hash) ->

has_post(Db, Hash) when is_binary(Hash) ->

get_channel_heads(Db, Chan) ->
    gen_server:call(Db, {channelsHeads, Chan}).

    io:format("[DB] Path: ~p~n", [Path]),

    LinkChan = proplists:get_value(channel, Body, null),

                          Row = [{source, {blob, PostHash}}, {parent, {blob, Link}}],

                          Row = [{source, {blob, PostHash}}, {parent, {blob, Link}}]
                              ++ case LinkChan of
                                     null -> [];
                                     _ -> [{channel, LinkChan}]
                                 end,

    Qry = "INSERT INTO users (public_key) VALUES (?) ON CONFLICT DO NOTHING;",
    {rowid, _RowId} = sqlite3:sql_exec(Db, Qry, [{blob, PubKey}]),
    [{columns, ["id","public_key","name"]},
     {rows, [{UserId, {blob, PubKey}, _Name}]}] = sqlite3:read(Db, users, {public_key, {blob, PubKey}}),

    UserId = get_or_create_user_id(Db, PubKey),

               0 -> Body; %% text
               3 -> Body; %% topic
               4 -> Body; %% join
               5 -> Body; %% leave

                   [{channel, Chan}, {infos, {blob, jsone:encode(Infos)}}]

                   [{channel, Chan}, {infos, {blob, jsone:encode(Infos)}}];
               %% text, topic, join or leave
               _ -> Body

    materialize_views(Db, Post),

    Qry = "SELECT hash from posts where channel = ? and timestamp >= ? and timestamp <= ? limit ?",

    Qry = "SELECT hash from posts where channel = ? and timestamp >= ? and timestamp <= ? and type = 0 limit ?",

handle_call({channelsHeads, Chan}, _, [{sql, Db}, _] = State) ->
    Qry = "SELECT hash, user_id from posts where channel = ? and type > 1 order by timestamp desc",
    QryChan = {blob, list_to_binary(Chan)},
    [{columns, ["hash", "user_id"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [QryChan]),
    JoinLeaveHashes = [Hash || {{blob, Hash}, _} <- Rows],
    InfoPostQry = "SELECT hash from posts where user_id = ? and type = 2",
    InfosHashes = lists:foldl(fun({_, UserId}, Acc) ->
                                      [{columns, ["hash"]},
                                       {rows, InfoRows}] = sqlite3:sql_exec(Db, InfoPostQry, [UserId]),
                                      case InfoRows of
                                          [{{blob, H}}] ->
                                              sets:add_element(H, Acc);
                                          [] ->
                                              Acc
                                      end
                              end, sets:new(), Rows),
    Result = JoinLeaveHashes ++ sets:to_list(InfosHashes),
    {reply, {ok, Result}, State};

    Qry = "SELECT hash from posts where channel = ? and type > 1 order by timestamp asc",
    QryChan = {blob, list_to_binary(Chan)},
    [{columns, ["hash"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [QryChan]),
    Result = [Hash || {{blob, Hash}} <- Rows],

    TopicQry = "SELECT topic from channels where name = ?",
    %QryChan = {blob, list_to_binary(Chan)},
    [{columns, ["topic"]}, {rows, [{TopicBin}]}] = sqlite3:sql_exec(Db, TopicQry, [Chan]),
    Topic = unicode:characters_to_list(TopicBin),
    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 = ?",
    io:format("[DEBUG] Members Qry:~n~s~n", [MembersQry]),
    [ {columns, ["name", "pub_key", "timestamp"]}
    , {rows, Rows}] = sqlite3:sql_exec(Db, MembersQry, [Chan]),
    io:format("[DEBUG] Rows: ~p~n", [Rows]),
    M = lists:foldl(fun(Row, Acc) ->
                            {NameBin, {blob, PubKey}, When} = Row,
                            Name = unicode:characters_to_list(NameBin),
                            Acc#{PubKey => {Name, When}}
                    end, #{}, Rows),
    Result = [{topic, Topic},
              {members, M}],

materialize_views(Db, Post) ->
    [
     [ {public_key, PubKey}
     , {links, _Links}
     , {type, Type}
     , {timestamp, _TimeStamp}
     , {hash, Hash}
     ],
     Body
    ] = Post,
    UserId = get_or_create_user_id(Db, PubKey),
    case Type of
        0 -> ok; %% text: nothing to do
        1 -> %% delete
            [ {hashes, Hashes} ] = Body,
            lists:foreach(fun(H) ->
                                  ok = sqlite3:delete(Db, posts, {hash, {blob, H}})
                          end, Hashes),
            ok;
        2 -> %% infos
            [ {infos, InfoMap} ] = Body,
            %% assert there is nothing else to evaluate
            {BinName, #{}} = maps:take(<<"name">>, InfoMap),
            Name = unicode:characters_to_list(BinName),
            ok = sqlite3:update(Db, users, {id, UserId}, [{name, Name}]),
            ok;
        3 -> %% topic
            [ {channel, Chan}, {topic, TopicBin} ] = Body,
            Topic = unicode:characters_to_list(TopicBin),
            ok = sqlite3:update(Db, channels, {name, Chan}, [{topic, Topic}]),
            ok;
        4 ->
            [ {channel, Chan} ] = Body,
            Res = sqlite3:write(Db, channel_members, [ {channel, Chan}
                                                     , {user_id, UserId}
                                                     , {post_hash, {blob, Hash}}]),
            {rowid, _} = Res,
            ok;
        5 ->
            [ {channel, Chan} ] = Body,
            Qry = "DELETE FROM channel_members where channel = ? and user_id = ?",
            ok = sqlite3:sql_exec(Db, Qry, [Chan, UserId]),
            ok
    end.
get_or_create_user_id(Db, PubKey) ->
    Qry = "INSERT INTO users (public_key, name) VALUES (?, '') ON CONFLICT DO NOTHING;",
    {rowid, _RowId} = sqlite3:sql_exec(Db, Qry, [{blob, PubKey}]),
    [{columns, ["id","public_key","name"]},
     {rows, [{UserId, {blob, PubKey}, _Name}]}] = sqlite3:read(Db, users, {public_key, {blob, PubKey}}),
    UserId.

{_RowId, {blob, Hash}, Type, Timestamp, UserId, {blob, RawPost},

    {_RowId, {blob, Hash}, Type, Timestamp, UserId, {blob, RawPost},

    [{columns, ["source", "parent"]},

    [{columns, ["channel", "source", "parent"]},

    Links = [Parent || {{blob, _Source}, {blob, Parent}} <-LinkRows],

    Links = [Parent || {_, {blob, _Source}, {blob, Parent}} <-LinkRows],

               users => [ColId, {public_key, blob, [unique, not_null]}, {name, text}]

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