{ok, Id, Hash} = db:savePost(Db, Decoded, Bin),

    {ok, Id, Hash} = db:save_post(Db, Decoded, Bin),

    {ok, [Header, Body, Bin]} = db:loadPost(Db, Id),
    {ok, [Header, Body, Bin]} = db:loadPost(Db, Hash),
    ?assertEqual(true, db:hasPost(Db, Hash)),

    {ok, [Header, Body, Bin]} = db:load_post(Db, Id),
    {ok, [Header, Body, Bin]} = db:load_post(Db, Hash),
    ?assertEqual(true, db:has_post(Db, Hash)),

    ?assertEqual(false, db:hasPost(Db, Rand)),

    ?assertEqual(false, db:has_post(Db, Rand)),

                   {ok, Id, Hash} = db:savePost(Db, Decoded, Bin),

                   {ok, Id, Hash} = db:save_post(Db, Decoded, Bin),

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

                   {ok, [LoadedHeader, LoadedBody, LoadedBin]} = db:load_post(Db, Id),

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

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

                   ?assert(db:hasPost(Db, Hash))

                   ?assert(db:has_post(Db, Hash))

channel_time_range_test() ->
    Ex = examples:post_text(),
    Db = open_db(?current_function_name()),
    [{binary, Bin}, _] = Ex,
    Decoded = posts:decode(Bin),

    {ok, _Id, Hash} = db:save_post(Db, Bin),
    [Header, _Body] = Decoded,
    Ts = proplists:get_value(timestamp, Header),
    {ok, [GotHash]} = db:get_text_hashes_by_time_range(Db, "default", Ts-10, Ts+10, 1),
    ?assertEqual(Hash, GotHash).

%%%%%%%%%%%%
%% Decode %%
%%%%%%%%%%%%

% Decode

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

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

write(Pid, Chan, Text) ->
    gen_server:call(Pid, {writeTextToChannel, Chan, Text}).

    {ok, Chans} = db:channelsList(Db),

    {ok, Chans} = db:channels_list(Db),

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

        {writeTextToChannel, From, Chan, Text} ->
            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, {text, Chan, Text}),
                    {ok, _, PostHash} = db:save_post(Db, Bin),
                    SentPeers = lists:foldl(fun({received, ReqId, Peer}, AccPeers) ->
                                          {Peer, [Header, _]} = maps:get(ReqId, ActiveIn),
                                          case proplists:get_value(type, Header) of
                                              _ -> AccPeers; % ignored
                                              4 ->
                                                  {ok, {_, _, Size}} = send_hash_response(Peer, ReqId, [PostHash]),
                                                  update_peer_sent(AccPeers, Peer, Size)
                                          end
                                  end, Peers, maps:get(Chan, Chans)),
                    gen_server:reply(From, ok),
                    event_loop(State#state{peers = SentPeers})
                end;

                    {ok, _, _PostHash} = db:savePost(Db, Bin),
                    ok = db:channelsJoin(Db, Chan),

                    {ok, _, _PostHash} = db:save_post(Db, Bin),
                    ok = db:channels_join(Db, Chan),

                    {ok, _Id, _Hash} = db:savePost(Db, Bin),
                    ok = db:channelsLeave(Db, Chan),

                    {ok, _Id, _Hash} = db:save_post(Db, Bin),
                    ok = db:channels_leave(Db, Chan),

    io:format("[DEBUG] Body: ~p~n", [Body]),

    %io:format("[DEBUG] Body: ~p~n", [Body]),

                    FilterUnknownPosts = fun(H) -> not db:hasPost(Db, H) end,

                    FilterUnknownPosts = fun(H) -> not db:has_post(Db, H) end,

                    [{ok, _, _} = db:savePost(Db, P) || P <- Posts],

                    [{ok, _, _} = db:save_post(Db, P) || P <- Posts],

                                             case db:loadPost(Db, H) of

                                             case db:load_post(Db, H) of

                                                     io:format("[DEBUG] requested post not found~n"),

                                                 {ok, [_Head, _Body, Bin]} ->

                                                 {ok, [_, _, Bin]} ->
                                                     io:format("[DEBUG] replying with stored post~n"),

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

                            io:format("[DEBUG] Received incoming chan time req(~p) for ~p from ~p~n",
                                      [ReqIdStr, RequestedChan, Peer]),
                            [Start, End, Limit] = [proplists:get_value(F, Body) ||
                                                      F <- [timestart, timeend, limit]],
                            {ok, Hashes} = db:get_text_hashes_by_time_range(Db, RequestedChan, Start, End, Limit),
                            {ok, {_, _, RespSize}} = send_hash_response(Peer, ReqId, Hashes),
                            %% TODO: only track if 'end' is in the future

                              peers = NewPeers,

                              peers = update_peer_sent(NewPeers, Peer, RespSize),

                            io:format("[DEBUG] Received incoming state req for ~p from ~p~n", [RequestedChan, Peer]),
                            %% TODO: send recent channel state hashes

                            io:format("[DEBUG] Received incoming state req for ~p from ~p~n",
                                      [RequestedChan, Peer]),
                            {ok, Hashes} = db:get_channel_state(Db, RequestedChan),
                            {ok, {_, _, RespSize}} = send_hash_response(Peer, ReqId, Hashes),
                            %% TODO: only track if future is set to 1

                              peers = NewPeers,

                              peers = update_peer_sent(NewPeers, Peer, RespSize),

                    io:format("[Warning] unhandled incoming message of type ~p that isn't state:activeOut - RequestId:~p~n", [Unhandled, ReqIdStr]),

                    io:format("[Warning] unhandled incoming message (Type:~p|ReqId:~p) with activeOut:false~n",
                              [Unhandled, ReqIdStr]),

    ReqId =  crypto:strong_rand_bytes(4),

    ReqId = crypto:strong_rand_bytes(4),

    ReqId =  crypto:strong_rand_bytes(4),

    ReqId = crypto:strong_rand_bytes(4),

    ReqId =  crypto:strong_rand_bytes(4),

    ReqId = crypto:strong_rand_bytes(4),

    ReqId =  crypto:strong_rand_bytes(4),

    ReqId = crypto:strong_rand_bytes(4),

    io:format("[DEBUG] sending post response(~p) for ~p posts to ~p~n"
             , [hex:bin_to_hexstr(ReqId), length(Posts), Peer]),

send_hash_response(Peer, ReqId, Hashes) ->
    io:format("[DEBUG] sending hash response(~p) for ~p hashes to ~p~n"
             , [hex:bin_to_hexstr(ReqId), length(Hashes), Peer]),
    Header = [{requestId, ReqId},
              {circuitId, <<0,0,0,0>>}
             ],
    Binary = wire:encode_hash_response(Header, Hashes),
    send_binary_to_peer(Peer, Binary).

-export([start_link/1, close/1, savePost/3, savePost/2, loadPost/2, hasPost/2]).
-export([channelsJoin/2, channelsLeave/2, channelsList/1]).

-export([start_link/1, close/1, save_post/3, save_post/2, load_post/2]).
-export([has_post/2, get_text_hashes_by_time_range/5]).
-export([channels_join/2, channels_leave/2, channels_list/1, get_channel_state/2]).

savePost(Db, Post, Data) when is_binary(Data) ->

save_post(Db, Post, Data) when is_binary(Data) ->

savePost(Db, Data) when is_binary(Data) ->

save_post(Db, Data) when is_binary(Data) ->

loadPost(Db, IntId) when is_integer(IntId), IntId >= 0 ->

load_post(Db, IntId) when is_integer(IntId), IntId >= 0 ->

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

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

hasPost(Db, Hash) ->

has_post(Db, Hash) ->

get_text_hashes_by_time_range(Db, Chan, Start, End, Limit) ->
    ActualEnd = case End of
                    %% 00:00:00 01.01.2180
                    0 -> 66269664000;
                    _ -> End
                end,
    ActualLimit = case Limit of
                      0 -> 9001;
                      _ -> Limit
                  end,
    gen_server:call(Db, {hashesByTimeRange, Chan, Start, ActualEnd, ActualLimit}).

channelsJoin(Db, Name) ->

channels_join(Db, Name) ->

channelsLeave(Db, Name) ->

channels_leave(Db, Name) ->

channelsList(Db) ->

channels_list(Db) ->

get_channel_state(Db, Chan) ->
    gen_server:call(Db, {channelsState, Chan}).

handle_call({hashesByTimeRange, Chan, Start, End, Limit}, _From, [{sql, Db}, _] = State) ->
    Qry = "SELECT hash from posts where channel = ? and timestamp >= ? and timestamp <= ? limit ?",
    QryChan = {blob, list_to_binary(Chan)},
    [{columns, ["hash"]}, {rows, Rows}] = sqlite3:sql_exec(Db, Qry, [QryChan, Start, End, Limit]),
    Result = [Hash || {{blob, Hash}} <- Rows],
    {reply, {ok, Result}, State};

%% TODO: obviously incomplete
handle_call({channelsState, Chan}, _, [{sql, Db}, _] = 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],
    {reply, {ok, Result}, State};