%%%%%%%%%%%%%%%%%%%%%%

    Chan =  "#foo",

    Chan =  <<"#foo">>,

                                                % from example tests

%% from example tests
%%%%%%%%%%%%%%%%%%%%%

    ?assertEqual("default", Channel),

    ?assertEqual(<<"default">>, Channel),

                                                % TODO: assert Hash values

    %% TODO: assert Hash values

                                                % Helpers
%%%%%%%%%

%% Helpers
%%%%%%%%%%

    [{binary, Bin}, {obj, TestObj}] = examples:post_text(),

    [{binary, Bin}, _] = examples:post_text(),

    [
     [ {public_key, _PubKey}
     , {signature, _Sig}
     , {links, _Links}
     , {type, 0}
     , {timestamp, _TimeStamp}
     , {hash, Hash}
     ],
     [ {channel, Channel}
     , {text, Text}
     ]
    ] = Decoded,

    [Header, _] = Decoded,
    Hash = proplists:get_value(hash, Header),

    ?assertEqual(LoadedPost, LoadedByHash),

    ?assertEqual(Decoded, LoadedByHash),
    db:close(Db).
all_posts_test() ->
    Examples = [ examples:post_text()
               , examples:post_delete()
               , examples:post_info()
               , examples:post_topic()
               , examples:post_join()
               , examples:post_leave()
               ],
    Db = open_db(?current_function_name()),
    Test = fun(Ex) ->
                   [{binary, Bin}, _] = Ex,
                   Decoded = posts:decode(Bin),
                   [Header, _] = Decoded,
                   {ok, Id} = db:savePost(Db, Decoded),
                   ?assert(is_integer(Id)),
                   {ok, LoadedPost} = db:loadPost(Db, Id),
                   ?assertEqual(Decoded, LoadedPost),
                   Hash = proplists:get_value(hash, Header),
                   {ok, LoadedByHash} = db:loadPost(Db, Hash),
                   ?assertEqual(Decoded, LoadedByHash)
           end,
    lists:foreach(Test, Examples),

  channel text,       -- all but delete have this one

  channel text,          -- all but delete have this one

  infos blob,           -- encoded as (json?) map {k=>v, k=>v}

  infos blob,            -- encoded as (json?) map {k=>v, k=>v}

    type != 2 OR (channel is not null AND infos is not null)

    type != 2 OR (infos is not null)

  [ {channel, binary_to_list(Channel)}, {text, unicode:characters_to_binary(Text)}].

  [ {channel, Channel}, {text, unicode:characters_to_binary(Text)}].

                                        _TODO -> erlang:error("TODO")

                                        2 -> %% infos
                                            Chan = proplists:get_value(channel, Body),
                                            Infos = proplists:get_value(infos, Body),
                                            [{channel, Chan}, {infos, {blob, jsone:encode(Infos)}}];
                                        3 -> %% topic
                                            Body;
                                        %% join / leave
                                        4 -> Body;
                                        5 -> Body

    %% [io:format("[Db/DEBUG] ~p~n", [I]) || I <- Prepared],

    %% [io:format("[Db/DEBUG] Prepared: ~p~n", [I]) || I <- Prepared],

    [{columns, _Cols}, {rows, [Row]}] = sqlite3:read(Db, posts, {hash, {blob, Hash}}),
    {reply, {error, "TODO:loadHash"}, State};

    Res= sqlite3:read(Db, posts, {hash, {blob, Hash}}),
    {reply, {ok, unpackPost(Db, Res)}, State};

    ExpectedCols = ["id", "hash", "type", "timestamp", "public_key", "signature", "channel", "text", "topic", "deletedHashes", "infos"],
    [{columns, ExpectedCols}, {rows, [Row]}] = sqlite3:read(Db, posts, {id, IntId}),
    {IntId, {blob, Hash}, Type, Timestamp, {blob, PubKey}, {blob, Sig}, Channel, TextBlob, Topic, Deleteds, Infos} = Row,
    [{columns, ["source", "parent"]}, {rows, LinkRows}] = sqlite3:read(Db, links, {source, {blob, Hash}}),
    Links = [Parent || {{blob, _Source}, {blob, Parent}} <-LinkRows],
    [io:format("[DEBUG] Links:~p~n", [I]) || I <- Links],
    Header = [ {public_key, PubKey}
             , {signature, Sig}
             , {links, Links}
             , {type, Type}
             , {timestamp, Timestamp}
             , {hash, Hash}
             ],
    Body = case Type of
               0 ->
                   {blob, Text} = TextBlob,
                   %% TODO: utf8 channels
                   [{channel,binary_to_list(Channel)}, {text, Text}];
               _ -> io:format("TODO type: ~p~n", [Type])
           end,
    {reply, {ok, [Header, Body]}, State};

    Res = sqlite3:read(Db, posts, {id, IntId}),
    Post = unpackPost(Db, Res),
    {reply, {ok, Post}, State};

unpackPost(Db, ReadResult) ->
    ExpectedCols = ["id", "hash", "type", "timestamp", "public_key", "signature", "channel", "text", "topic", "deletedHashes", "infos"],
    [{columns, ExpectedCols}, {rows, [Row]}] = ReadResult,
    {_RowId, {blob, Hash}, Type, Timestamp, {blob, PubKey}, {blob, Sig},
     ChannelBlob, TextBlob, TopicBlob, Deleteds, InfosBlob} = Row,
    [{columns, ["source", "parent"]}, {rows, LinkRows}] = sqlite3:read(Db, links, {source, {blob, Hash}}),
    Links = [Parent || {{blob, _Source}, {blob, Parent}} <-LinkRows],
    [io:format("[DEBUG] Links:~p~n", [I]) || I <- Links],
    Header = [ {public_key, PubKey}
             , {signature, Sig}
             , {links, Links}
             , {type, Type}
             , {timestamp, Timestamp}
             , {hash, Hash}
             ],
    %% TODO: utf8 channels
    Body = case Type of
               0 ->
                   {blob, Text} = TextBlob,
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}, {text, Text}];
               1 ->
                   {blob, DeletedConcat} = Deleteds,
                   [{hashes, split_concated_hashes(DeletedConcat)}];
               2 ->
                   {blob, InfosJson} = InfosBlob,
                   [{infos, jsone:decode(InfosJson)}];
               3 ->
                   {blob, Topic} = TopicBlob,
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}, {topic, Topic}];
               4 ->
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}];
               5 ->
                   {blob, Channel} = ChannelBlob,
                   [{channel, Channel}]
           end,
    [Header, Body].

split_concated_hashes(Hashes) when is_binary(Hashes) ->
    split_concated_hashes(Hashes, []).
split_concated_hashes(Bin, Acc) when byte_size(Bin) > 0 ->
    <<H:32/binary, Rest/binary>> = Bin,
    split_concated_hashes(Rest, Acc ++ [H]);
split_concated_hashes(<<>>, Acc) ->
     Acc.