trove

-module(trove@internal@btree@node).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/trove/internal/btree/node.gleam").
-export([node_kind/1, is_leaf/1, encode_data_node/2, encode_tombstone/0, decode_data_node/2, is_tombstone/1, extract_locations/1, validate_structure/1, encode_tree_node/2, decode_tree_node/2, decode_any_node/3]).
-export_type([tree_node/1, data_node/1, any_node/2, node_kind/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-type tree_node(HCQ) :: {leaf, non_empty_list:non_empty_list({HCQ, integer()})} |
    {branch, non_empty_list:non_empty_list({HCQ, integer()})}.

-type data_node(HCR) :: {value, HCR} | deleted.

-type any_node(HCS, HCT) :: {tree, tree_node(HCS)} | {data, data_node(HCT)}.

-type node_kind() :: tree_kind | data_kind.

-file("src/trove/internal/btree/node.gleam", 42).
?DOC(false).
-spec node_kind(bitstring()) -> {ok, node_kind()} | {error, nil}.
node_kind(Data) ->
    case Data of
        <<16#01, _/bitstring>> ->
            {ok, tree_kind};

        <<16#02, _/bitstring>> ->
            {ok, tree_kind};

        <<16#03, _/bitstring>> ->
            {ok, data_kind};

        <<16#04, _/bitstring>> ->
            {ok, data_kind};

        _ ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 50).
?DOC(false).
-spec is_leaf(bitstring()) -> boolean().
is_leaf(Data) ->
    case Data of
        <<16#01, _/bitstring>> ->
            true;

        _ ->
            false
    end.

-file("src/trove/internal/btree/node.gleam", 71).
?DOC(false).
-spec encode_data_node(data_node(HCZ), trove@codec:codec(HCZ)) -> bitstring().
encode_data_node(Node, Value_codec) ->
    case Node of
        {value, Value} ->
            Value_bytes = (erlang:element(2, Value_codec))(Value),
            gleam_stdlib:bit_array_concat([<<16#03>>, Value_bytes]);

        deleted ->
            <<16#04>>
    end.

-file("src/trove/internal/btree/node.gleam", 85).
?DOC(false).
-spec encode_tombstone() -> bitstring().
encode_tombstone() ->
    <<16#04>>.

-file("src/trove/internal/btree/node.gleam", 116).
?DOC(false).
-spec decode_data_node(bitstring(), trove@codec:codec(HDH)) -> {ok,
        data_node(HDH)} |
    {error, nil}.
decode_data_node(Data, Value_codec) ->
    case Data of
        <<16#03, Rest/bitstring>> ->
            gleam@result:map(
                (erlang:element(3, Value_codec))(Rest),
                fun(Value) -> {value, Value} end
            );

        <<16#04>> ->
            {ok, deleted};

        _ ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 131).
?DOC(false).
-spec is_tombstone(bitstring()) -> boolean().
is_tombstone(Data) ->
    Data =:= <<16#04>>.

-file("src/trove/internal/btree/node.gleam", 163).
?DOC(false).
-spec collect_n_locations(bitstring(), integer(), list(integer())) -> {ok,
        list(integer())} |
    {error, nil}.
collect_n_locations(Data, Remaining, Acc) ->
    case {Remaining, Data} of
        {0, <<>>} ->
            {ok, lists:reverse(Acc)};

        {_, <<Key_size:32, _:Key_size/binary, Location:64/big, Tail/bitstring>>} ->
            collect_n_locations(Tail, Remaining - 1, [Location | Acc]);

        {_, _} ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 156).
?DOC(false).
-spec extract_locations_from_entries(bitstring()) -> {ok, list(integer())} |
    {error, nil}.
extract_locations_from_entries(Data) ->
    case Data of
        <<Count:32, Rest/bitstring>> when Count > 0 ->
            collect_n_locations(Rest, Count, []);

        _ ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 148).
?DOC(false).
-spec extract_locations(bitstring()) -> {ok, list(integer())} | {error, nil}.
extract_locations(Data) ->
    case Data of
        <<16#01, Rest/bitstring>> ->
            extract_locations_from_entries(Rest);

        <<16#02, Rest/bitstring>> ->
            extract_locations_from_entries(Rest);

        _ ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 190).
?DOC(false).
-spec validate_n_entries_structure(bitstring(), integer()) -> boolean().
validate_n_entries_structure(Data, Remaining) ->
    case {Remaining, Data} of
        {0, <<>>} ->
            true;

        {_, <<Key_size:32, _:Key_size/binary, _:64/big, Tail/bitstring>>} ->
            validate_n_entries_structure(Tail, Remaining - 1);

        {_, _} ->
            false
    end.

-file("src/trove/internal/btree/node.gleam", 182).
?DOC(false).
-spec validate_entries_structure(bitstring()) -> boolean().
validate_entries_structure(Data) ->
    case Data of
        <<Count:32, Rest/bitstring>> when Count > 0 ->
            validate_n_entries_structure(Rest, Count);

        _ ->
            false
    end.

-file("src/trove/internal/btree/node.gleam", 138).
?DOC(false).
-spec validate_structure(bitstring()) -> boolean().
validate_structure(Data) ->
    case Data of
        <<16#01, Rest/bitstring>> ->
            validate_entries_structure(Rest);

        <<16#02, Rest/bitstring>> ->
            validate_entries_structure(Rest);

        _ ->
            false
    end.

-file("src/trove/internal/btree/node.gleam", 221).
?DOC(false).
-spec encode_entries(list({HEE, integer()}), trove@codec:codec(HEE)) -> bitstring().
encode_entries(Entries, Key_codec) ->
    Count = erlang:length(Entries),
    Entry_bits = gleam@list:map(
        Entries,
        fun(Entry) ->
            {Key, Location} = Entry,
            Key_bytes = (erlang:element(2, Key_codec))(Key),
            Key_size = erlang:byte_size(Key_bytes),
            gleam_stdlib:bit_array_concat(
                [<<Key_size:32>>, Key_bytes, <<Location:64/integer-big>>]
            )
        end
    ),
    gleam_stdlib:bit_array_concat([<<Count:32>> | Entry_bits]).

-file("src/trove/internal/btree/node.gleam", 58).
?DOC(false).
-spec encode_tree_node(tree_node(HCW), trove@codec:codec(HCW)) -> bitstring().
encode_tree_node(Node, Key_codec) ->
    {Tag, Children@2} = case Node of
        {leaf, Children} ->
            {<<16#01>>, non_empty_list:to_list(Children)};

        {branch, Children@1} ->
            {<<16#02>>, non_empty_list:to_list(Children@1)}
    end,
    Payload = encode_entries(Children@2, Key_codec),
    gleam_stdlib:bit_array_concat([Tag, Payload]).

-file("src/trove/internal/btree/node.gleam", 250).
?DOC(false).
-spec decode_n_entries(
    bitstring(),
    integer(),
    trove@codec:codec(HEM),
    list({HEM, integer()})
) -> {ok, list({HEM, integer()})} | {error, nil}.
decode_n_entries(Data, Remaining, Key_codec, Acc) ->
    case {Remaining, Data} of
        {0, <<>>} ->
            {ok, lists:reverse(Acc)};

        {_,
            <<Key_size:32,
                Key_bytes:Key_size/binary,
                Location:64/big,
                Tail/bitstring>>} ->
            gleam@result:'try'(
                (erlang:element(3, Key_codec))(Key_bytes),
                fun(Key) ->
                    decode_n_entries(
                        Tail,
                        Remaining - 1,
                        Key_codec,
                        [{Key, Location} | Acc]
                    )
                end
            );

        {_, _} ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 240).
?DOC(false).
-spec decode_entries(bitstring(), trove@codec:codec(HEH)) -> {ok,
        list({HEH, integer()})} |
    {error, nil}.
decode_entries(Data, Key_codec) ->
    case Data of
        <<Count:32, Rest/bitstring>> ->
            decode_n_entries(Rest, Count, Key_codec, []);

        _ ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 91).
?DOC(false).
-spec decode_tree_node(bitstring(), trove@codec:codec(HDC)) -> {ok,
        tree_node(HDC)} |
    {error, nil}.
decode_tree_node(Data, Key_codec) ->
    case Data of
        <<16#01, Rest/bitstring>> ->
            gleam@result:'try'(
                decode_entries(Rest, Key_codec),
                fun(Entries) ->
                    gleam@result:map(
                        begin
                            _pipe = non_empty_list:from_list(Entries),
                            gleam@result:replace_error(_pipe, nil)
                        end,
                        fun(Nel) -> {leaf, Nel} end
                    )
                end
            );

        <<16#02, Rest@1/bitstring>> ->
            gleam@result:'try'(
                decode_entries(Rest@1, Key_codec),
                fun(Entries@1) ->
                    gleam@result:map(
                        begin
                            _pipe@1 = non_empty_list:from_list(Entries@1),
                            gleam@result:replace_error(_pipe@1, nil)
                        end,
                        fun(Nel@1) -> {branch, Nel@1} end
                    )
                end
            );

        _ ->
            {error, nil}
    end.

-file("src/trove/internal/btree/node.gleam", 206).
?DOC(false).
-spec decode_any_node(
    bitstring(),
    trove@codec:codec(HDW),
    trove@codec:codec(HDY)
) -> {ok, any_node(HDW, HDY)} | {error, nil}.
decode_any_node(Data, Key_codec, Value_codec) ->
    case decode_tree_node(Data, Key_codec) of
        {ok, Tree_node} ->
            {ok, {tree, Tree_node}};

        {error, nil} ->
            case decode_data_node(Data, Value_codec) of
                {ok, Data_node} ->
                    {ok, {data, Data_node}};

                {error, nil} ->
                    {error, nil}
            end
    end.