%?assert(false),

hashing_test() ->
    Table = [ { "Two hands clap and there is a sound. What is the sound of one hand?"
              , "fcd7c41883c3564c5a6abec78e214159efe62d50f124b4afafc184ea3b764cd4"}
            , { "茶色"
              , "46b321c236880cd861dafae3040cf8cc52990516d1a69ab2c170b1e615a7ebd5"}
            , { "elf"
              , "ffe809405a3e1eaf77938bde2138832b177a51e47df02935edc12aacf8279f61"}
            , { "love collapses spacetime"
              , "fea16c09f8aa581500fcf6ee2f6aabc59ccaa271d2a3568843930b7ff929ad86"}
            ],
    lists:foreach(fun({InStr, Want}) ->
                          In = unicode:characters_to_binary(InStr),
                          %WantBin = hex:hexstr_to_bin(Want),
                          Got = enacl:generichash(32, In),
                          %?assertEqual(WantBin, Got)
                          GotHex = hex:bin_to_hexstr(Got),
                          ?assertEqual(Want, string:lowercase(GotHex))
                  end, Table).

    ?assertEqual(true, db:hasPost(Db, Hash)),
    Rand = crypto:strong_rand_bytes(32),
    ?assertEqual(false, db:hasPost(Db, Rand)),

                   {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:loadPost(Db, Hash)

                   {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:loadPost(Db, Hash),
                   ?assert(db:hasPost(Db, Hash))

    ?assertEqual(maps:get(<<"channel">>, TestObj), Channel),

    WantCh = binary_to_list(maps:get(<<"channel">>, TestObj)),
    ?assertEqual(WantCh, Channel),

    ?assertEqual(maps:get(<<"channel">>, TestObj), Channel),

    WantCh = binary_to_list(maps:get(<<"channel">>, TestObj)),
    ?assertEqual(WantCh, Channel),

    ?assertEqual(<<"Foo">>, proplists:get_value(channel, Body)),

    ?assertEqual("Foo", proplists:get_value(channel, Body)),

  hash blob unique not null check (length(hash) = 64),

  hash blob unique not null check (length(hash) = 32),

         encode_channel_time_trange_request/5,

         encode_channel_time_range_request/5,

encode_channel_time_trange_request(Header, Channel, Start, End, Limit) ->

encode_channel_time_range_request(Header, Channel, Start, End, Limit) ->

    , {channel, Channel}

    , {channel, binary_to_list(Channel)}

    , {channel, Channel}

    , {channel, binary_to_list(Channel)}

            PostHash = crypto:hash(blake2b, Data),

            PostHash = enacl:generichash(32, Data),

            %% TODO: figure out how to do this without copying Data

                              MsgSize = byte_size(Data),

                              %% TODO: this ommits the byte(s) for the length prefix
                              MsgSize = byte_size(Chunk),

            io:format("[DEBUG] Starting peerNew:~p~n", [Peer]),

            EachChan = fun(Chan, {AccChannels, PeerSent}) ->
                               {ok, {ReqId, Msg, Size}} = send_channel_state_request(Peer, Chan, true),
                               ReqsForChan = maps:get(Chan, AccChannels, []),

            EachChan = fun(Chan, {AccNewReqs, AccChannels, PeerSent}) ->
                               {ok, {StateReqId, StateMsg, StateSize}} = send_channel_state_request(Peer, Chan, true),
                               End = os:system_time(1000),
                               Start = End - (12*60*60 * 1000),
                               {ok, {TimeReqId, TimeMsg, TimeSize}
                               } = send_channel_time_range_request(Peer, Chan, Start, End, 100),
                               ReqsForChan = maps:get(Chan, AccChannels, [])
                                   ++ [{sent, StateReqId, Peer}]
                                   ++ [{sent, TimeReqId, Peer}],

                                {ReqId, Msg},
                                {
                                 maps:update(Chan, ReqsForChan ++ [{sent, ReqId, Peer}], AccChannels),
                                 PeerSent + Size
                                }

                                AccNewReqs ++ [{StateReqId, StateMsg}, {TimeReqId, TimeMsg}],
                                maps:update(Chan, ReqsForChan, AccChannels),
                                PeerSent + StateSize + TimeSize

            {NewRequests, {NewChans, PeerSent}} = lists:mapfoldl(EachChan, {Chans, 0}, maps:keys(Chans)),
            %% Update the helper map for active outgoing ones

            {NewRequests, NewChans, PeerSent} = lists:foldl(EachChan, {[], Chans, 0}, maps:keys(Chans)),
            %% Update the helper map for active outgoing reqs

                              address => io_lib:format("~p:~p", [Addr, Port]),
                              lastSeenAt => os:system_time(1000),
                              bytesTransmitted => {PeerSent, 0}

                             address => {Addr, Port},
                             lastSeenAt => os:system_time(1000),
                             bytesTransmitted => {PeerSent, 0}

            io:format("[DEBUG] Peer ~p added to event loop state~n", [Peer]),

            io:format("[Peer] Tracking new connection ~p ~n", [Peer]),

                    self() ! {stateChange, Chan},

                                       %% TODO: push post into open requests

                    self() ! {stateChange, Chan},

                                      %% TODO: push post into open requests
                                      {{Peer, _Msg}, NewActiveOuts} = maps:take(ReqId, AccActiveOuts),

                                      {{Peer, _}, NewActiveOuts} = maps:take(ReqId, AccActiveOuts),

                                      {ok, {CancelReqId, Msg, Size}} = send_cancel_request(Peer, ReqId),

                                      {ok, {_, _, Size}} = send_cancel_request(Peer, ReqId),

                                       maps:put(CancelReqId, {Peer, Msg}, NewActiveOuts),

                                       NewActiveOuts,

            event_loop(State);
        {stateChange, Chan} ->
            io:format("[DEBUG] state change of ~p~n", [Chan]),

    NewPeers = update_peer_received(Peers, Peer, MsgSize),

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

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

                    %% TODO: keep track of which we asked for
                    {ok, {PostReqId, _PostReqMsg, Size}} = send_post_request(Peer, NewHashes),
                    UpdatedOut = maps:put(PostReqId, Peer, ActiveOut),
                    %% update loop state
                    S#state{
                      peers = update_peer_sent(Peers, Peer, Size),
                      activeOut = UpdatedOut
                     };

                    case length(NewHashes) of
                        0 -> % nothing to request
                            S#state{peers = NewPeers};
                        _ ->
                            %% TODO: keep track of which hashes we asked for
                            {ok, {PostReqId, _PostReqMsg, SentSize}} = send_post_request(Peer, NewHashes),
                            UpdatedOut = maps:put(PostReqId, Peer, ActiveOut),
                            %% update loop state
                            S#state{
                              peers = update_peer_sent(NewPeers, Peer, SentSize),
                              activeOut = UpdatedOut
                             }
                        end;

                    S

                    S#state{peers = NewPeers}

                        error -> S; % ignore

                        error ->  % ignore
                            S#state{peers = NewPeers};

                              peers = update_peer_received(Peers, Peer, MsgSize),

                              peers = NewPeers,

                        error -> S; % ignore

                        error -> % ignore
                            S#state{peers = NewPeers};

                            %% TODO: send current state
                            io:format("[TEMP] Received incoming chan time req for ~p from ~p~n", [RequestedChan, Peer]),

                            io:format("[DEBUG] Received incoming chan time req for ~p from ~p~n", [RequestedChan, Peer]),
                            %% TODO: send posts

                              peers = update_peer_received(Peers, Peer, MsgSize),

                              peers = NewPeers,

                        error -> S; % ignore

                        error -> % ignore
                            S#state{peers = NewPeers};

                            io:format("[DEBUG] Received incoming state req for ~p from ~p~n", [RequestedChan, Peer]),

                            io:format("[TEMP] Received incoming state req for ~p from ~p~n", [RequestedChan, Peer]),

                              peers = update_peer_received(Peers, Peer, MsgSize),

                              peers = NewPeers,

                    RxPeers = update_peer_received(Peers, Peer, MsgSize),

                    RTxPeers = update_peer_sent(RxPeers, Peer, ResponseSize),

                    RTxPeers = update_peer_sent(NewPeers, Peer, ResponseSize),

                    S

                    S#state{peers = NewPeers}

send_channel_time_range_request(Peer, Channel, Start, End, Limit) ->
    ReqId =  crypto:strong_rand_bytes(4),
    io:format("[DEBUG] sending channel time range request(~p) for ~p to ~p~n"
             , [hex:bin_to_hexstr(ReqId), Channel, Peer]),
    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>},
              {ttl, 3}],
    Binary = wire:encode_channel_time_range_request(Header, Channel, Start, End, Limit),
    send_binary_to_peer(Peer, Binary).

update_peer_sent(Peers, Peer, Size) when is_map(Peers) and is_integer(Size) ->

update_peer_sent(Peers, Peer, Size) when is_map(Peers), is_integer(Size) ->

update_peer_received(Peers, Peer, Size) when is_map(Peers) and is_integer(Size) ->

update_peer_received(Peers, Peer, Size) when is_map(Peers), is_integer(Size) ->

                                 {Col, case Val of
                                           _ when is_binary(Val) -> {blob, Val};
                                           _ -> Val
                                       end}

                                 X = case Val of
                                         _ when is_binary(Val) -> {blob, Val};
                                         _ -> Val
                                     end,
                                 {Col, X}

    io:format("[DB] checking hasPost for ~p~n", [Hash]),