nimiq_gleam

-module(utils@serde).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([serialize_bytes/2, deserialize_bytes/1, serialize_bitarray/2, deserialize_bitarray/2, serialize_string/2, deserialize_string/1, serialize_int/3, deserialize_int/2, serialize_coin/2, deserialize_coin/1, serialize_bool/2, deserialize_bool/1]).

-file("src/utils/serde.gleam", 7).
-spec serialize_bytes(gleam@bytes_tree:bytes_tree(), bitstring()) -> gleam@bytes_tree:bytes_tree().
serialize_bytes(Buf, Data) ->
    _pipe = Buf,
    _pipe@1 = gleam@bytes_tree:append(
        _pipe,
        'Elixir.Varint.LEB128':encode(erlang:byte_size(Data))
    ),
    gleam@bytes_tree:append(_pipe@1, Data).

-file("src/utils/serde.gleam", 15).
-spec deserialize_bytes(bitstring()) -> {ok, {bitstring(), bitstring()}} |
    {error, binary()}.
deserialize_bytes(Buf) ->
    {Len, Rest} = 'Elixir.Varint.LEB128':decode(Buf),
    case Rest of
        <<Data:Len/binary-unit:8, Rest@1/bitstring>> ->
            {ok, {Data, Rest@1}};

        _ ->
            {error, <<"Invalid bytes: out of data"/utf8>>}
    end.

-file("src/utils/serde.gleam", 23).
-spec serialize_bitarray(gleam@bytes_tree:bytes_tree(), bitstring()) -> gleam@bytes_tree:bytes_tree().
serialize_bitarray(Buf, Data) ->
    _pipe = Buf,
    gleam@bytes_tree:append(_pipe, Data).

-file("src/utils/serde.gleam", 27).
-spec deserialize_bitarray(bitstring(), integer()) -> {ok,
        {bitstring(), bitstring()}} |
    {error, binary()}.
deserialize_bitarray(Buf, Length) ->
    case Buf of
        <<Data:Length/binary-unit:8, Rest/bitstring>> ->
            {ok, {Data, Rest}};

        _ ->
            {error, <<"Invalid bitarray: out of data"/utf8>>}
    end.

-file("src/utils/serde.gleam", 37).
-spec serialize_string(gleam@bytes_tree:bytes_tree(), binary()) -> gleam@bytes_tree:bytes_tree().
serialize_string(Buf, Str) ->
    _pipe = Buf,
    _pipe@1 = gleam@bytes_tree:append(
        _pipe,
        'Elixir.Varint.LEB128':encode(erlang:byte_size(Str))
    ),
    gleam@bytes_tree:append_string(_pipe@1, Str).

-file("src/utils/serde.gleam", 45).
-spec deserialize_string(bitstring()) -> {ok, {binary(), bitstring()}} |
    {error, binary()}.
deserialize_string(Buf) ->
    {Len, Rest} = 'Elixir.Varint.LEB128':decode(Buf),
    case Rest of
        <<Data:Len/binary-unit:8, Rest@1/bitstring>> ->
            case gleam@bit_array:to_string(Data) of
                {ok, Str} ->
                    {ok, {Str, Rest@1}};

                {error, _} ->
                    {error, <<"Invalid string: invalid UTF-8"/utf8>>}
            end;

        _ ->
            {error, <<"Invalid string: out of data"/utf8>>}
    end.

-file("src/utils/serde.gleam", 58).
-spec serialize_int(gleam@bytes_tree:bytes_tree(), integer(), integer()) -> gleam@bytes_tree:bytes_tree().
serialize_int(Buf, Num, Bit_size) ->
    _pipe = Buf,
    gleam@bytes_tree:append(_pipe, <<Num:(lists:max([(Bit_size), 0]))>>).

-file("src/utils/serde.gleam", 63).
-spec deserialize_int(bitstring(), integer()) -> {ok, {integer(), bitstring()}} |
    {error, binary()}.
deserialize_int(Buf, Bit_size) ->
    case Buf of
        <<Num:Bit_size, Rest/bitstring>> ->
            {ok, {Num, Rest}};

        _ ->
            {error, <<"Invalid number: out of data"/utf8>>}
    end.

-file("src/utils/serde.gleam", 73).
-spec serialize_coin(gleam@bytes_tree:bytes_tree(), coin:coin()) -> gleam@bytes_tree:bytes_tree().
serialize_coin(Buf, Coin) ->
    serialize_int(Buf, erlang:element(2, Coin), 64).

-file("src/utils/serde.gleam", 77).
-spec deserialize_coin(bitstring()) -> {ok, {coin:coin(), bitstring()}} |
    {error, binary()}.
deserialize_coin(Buf) ->
    case Buf of
        <<Luna:64, Rest/bitstring>> ->
            {ok, {{coin, Luna}, Rest}};

        _ ->
            {error, <<"Invalid coin: out of data"/utf8>>}
    end.

-file("src/utils/serde.gleam", 84).
-spec serialize_bool(gleam@bytes_tree:bytes_tree(), boolean()) -> gleam@bytes_tree:bytes_tree().
serialize_bool(Buf, Value) ->
    serialize_int(Buf, case Value of
            true ->
                1;

            false ->
                0
        end, 8).

-file("src/utils/serde.gleam", 95).
-spec deserialize_bool(bitstring()) -> {ok, {boolean(), bitstring()}} |
    {error, binary()}.
deserialize_bool(Buf) ->
    case Buf of
        <<0:8, Rest/bitstring>> ->
            {ok, {false, Rest}};

        <<1:8, Rest@1/bitstring>> ->
            {ok, {true, Rest@1}};

        _ ->
            {error, <<"Invalid bool: out of data"/utf8>>}
    end.