acrostic

-module(acrostic@decoding).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to_varint/2, decode_to_int/1, decode_to_bool/1, decode_to_i32/1, decode_to_i64/1, decode_to_string/1, decode_field/3, decode_repeated_field/3, read_key/1]).
-export_type([key/0, field_decoder/1, read_result/0]).

-type key() :: {key, integer(), acrostic@wire:wire_type()}.

-type field_decoder(KCY) :: {field_decoder,
        acrostic@wire:wire_type(),
        fun((bitstring()) -> {ok, KCY} | {error, binary()})}.

-type read_result() :: {read_result, bitstring(), bitstring()}.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 22).
-spec to_varint(bitstring(), integer()) -> integer().
to_varint(Binary, Acc) ->
    Len = erlang:byte_size(Binary),
    case Binary of
        <<Byte, Rest/bitstring>> ->
            to_varint(
                Rest,
                erlang:'bsl'(erlang:'band'(Byte, 16#7F), (Len - 1) * 7) + Acc
            );

        _ ->
            Acc
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 36).
-spec decode_to_int(bitstring()) -> {ok, integer()} | {error, binary()}.
decode_to_int(Binary) ->
    {ok, to_varint(Binary, 0)}.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 40).
-spec decode_to_bool(bitstring()) -> {ok, boolean()} | {error, binary()}.
decode_to_bool(Binary) ->
    case to_varint(Binary, 0) of
        0 ->
            {ok, false};

        1 ->
            {ok, true};

        _ ->
            {error,
                <<"Decode to bool failed: "/utf8,
                    (gleam_stdlib:bit_array_base64_encode(Binary, false))/binary>>}
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 49).
-spec decode_to_i32(bitstring()) -> {ok, float()} | {error, binary()}.
decode_to_i32(Binary) ->
    case Binary of
        <<F:32/float-little>> ->
            {ok, F};

        _ ->
            {error,
                <<"Decode to i32 failed: "/utf8,
                    (gleam_stdlib:bit_array_base64_encode(Binary, false))/binary>>}
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 57).
-spec decode_to_i64(bitstring()) -> {ok, float()} | {error, binary()}.
decode_to_i64(Binary) ->
    case Binary of
        <<F:64/float-little>> ->
            {ok, F};

        _ ->
            {error,
                <<"Decode to i64 failed: "/utf8,
                    (gleam_stdlib:bit_array_base64_encode(Binary, false))/binary>>}
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 65).
-spec decode_to_string(bitstring()) -> {ok, binary()} | {error, binary()}.
decode_to_string(Binary) ->
    case begin
        _pipe = Binary,
        gleam@bit_array:to_string(_pipe)
    end of
        {ok, S} ->
            {ok, S};

        {error, _} ->
            {error,
                <<"Decode to string failed: "/utf8,
                    (gleam_stdlib:bit_array_base64_encode(Binary, false))/binary>>}
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 214).
-spec read_some_bytes(bitstring(), integer()) -> {ok, read_result()} |
    {error, binary()}.
read_some_bytes(Binary, Length) ->
    case erlang:byte_size(Binary) >= Length of
        true ->
            Readed = begin
                _pipe = gleam_stdlib:bit_array_slice(Binary, 0, Length),
                gleam@result:lazy_unwrap(
                    _pipe,
                    fun() -> erlang:error(#{gleam_error => panic,
                                message => <<"`panic` expression evaluated."/utf8>>,
                                module => <<"acrostic/decoding"/utf8>>,
                                function => <<"read_some_bytes"/utf8>>,
                                line => 218}) end
                )
            end,
            Rest = begin
                _pipe@1 = gleam_stdlib:bit_array_slice(
                    Binary,
                    Length,
                    erlang:byte_size(Binary) - Length
                ),
                gleam@result:lazy_unwrap(
                    _pipe@1,
                    fun() -> erlang:error(#{gleam_error => panic,
                                message => <<"`panic` expression evaluated."/utf8>>,
                                module => <<"acrostic/decoding"/utf8>>,
                                function => <<"read_some_bytes"/utf8>>,
                                line => 221}) end
                )
            end,
            {ok, {read_result, Readed, Rest}};

        false ->
            {error, <<"Read bytes failed"/utf8>>}
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 232).
-spec read_varint_byte(bitstring(), bitstring()) -> {ok, read_result()} |
    {error, binary()}.
read_varint_byte(Binary, R) ->
    case Binary of
        <<Byte, Binary@1/bitstring>> ->
            R@1 = <<R/bitstring, Byte:8>>,
            case erlang:'band'(Byte, 16#80) of
                0 ->
                    case erlang:byte_size(R@1) > 10 of
                        true ->
                            {error, <<"Invalid varint, over 10 bytes"/utf8>>};

                        false ->
                            {ok, {read_result, R@1, Binary@1}}
                    end;

                _ ->
                    read_varint_byte(Binary@1, R@1)
            end;

        _ ->
            {error, <<"Invalid ended of varint"/utf8>>}
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 228).
-spec read_varint_bytes(bitstring()) -> {ok, read_result()} | {error, binary()}.
read_varint_bytes(Binary) ->
    read_varint_byte(Binary, <<>>).

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 82).
-spec decode_field(bitstring(), acrostic@wire:wire_type(), field_decoder(KDO)) -> {ok,
        {KDO, bitstring()}} |
    {error, binary()}.
decode_field(Binary, Wire_type, Decoder) ->
    case Wire_type of
        var_int ->
            gleam@result:'try'(
                read_varint_bytes(Binary),
                fun(R) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R)),
                        fun(N) -> {ok, {N, erlang:element(3, R)}} end
                    )
                end
            );

        i64 ->
            gleam@result:'try'(
                read_some_bytes(Binary, 8),
                fun(R@1) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R@1)),
                        fun(N@1) -> {ok, {N@1, erlang:element(3, R@1)}} end
                    )
                end
            );

        i32 ->
            gleam@result:'try'(
                read_some_bytes(Binary, 4),
                fun(R@2) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R@2)),
                        fun(N@2) -> {ok, {N@2, erlang:element(3, R@2)}} end
                    )
                end
            );

        len ->
            gleam@result:'try'(
                read_varint_bytes(Binary),
                fun(R@3) ->
                    gleam@result:'try'(
                        decode_to_int(erlang:element(2, R@3)),
                        fun(L) ->
                            gleam@result:'try'(
                                read_some_bytes(erlang:element(3, R@3), L),
                                fun(R@4) ->
                                    gleam@result:'try'(
                                        (erlang:element(3, Decoder))(
                                            erlang:element(2, R@4)
                                        ),
                                        fun(V) ->
                                            {ok, {V, erlang:element(3, R@4)}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 161).
-spec decode_packed_numbers(bitstring(), field_decoder(KDX), list(KDX)) -> {ok,
        list(KDX)} |
    {error, binary()}.
decode_packed_numbers(Binary, Decoder, Results) ->
    case Binary of
        <<>> ->
            {ok, Results};

        _ ->
            gleam@result:'try'((case erlang:element(2, Decoder) of
                    var_int ->
                        read_varint_bytes(Binary);

                    i64 ->
                        read_some_bytes(Binary, 8);

                    i32 ->
                        read_some_bytes(Binary, 4);

                    _ ->
                        {error,
                            <<"Decode packed numbers failed: invalid wire_type"/utf8>>}
                end), fun(R) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R)),
                        fun(N) ->
                            decode_packed_numbers(
                                erlang:element(3, R),
                                Decoder,
                                [N | Results]
                            )
                        end
                    )
                end)
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 115).
-spec decode_repeated_field(
    bitstring(),
    acrostic@wire:wire_type(),
    field_decoder(KDS)
) -> {ok, {list(KDS), bitstring()}} | {error, binary()}.
decode_repeated_field(Binary, Wire_type, Decoder) ->
    case Wire_type of
        var_int ->
            gleam@result:'try'(
                read_varint_bytes(Binary),
                fun(R) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R)),
                        fun(N) -> {ok, {[N], erlang:element(3, R)}} end
                    )
                end
            );

        i64 ->
            gleam@result:'try'(
                read_some_bytes(Binary, 8),
                fun(R@1) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R@1)),
                        fun(N@1) -> {ok, {[N@1], erlang:element(3, R@1)}} end
                    )
                end
            );

        i32 ->
            gleam@result:'try'(
                read_some_bytes(Binary, 4),
                fun(R@2) ->
                    gleam@result:'try'(
                        (erlang:element(3, Decoder))(erlang:element(2, R@2)),
                        fun(N@2) -> {ok, {[N@2], erlang:element(3, R@2)}} end
                    )
                end
            );

        len ->
            gleam@result:'try'(
                read_varint_bytes(Binary),
                fun(R@3) ->
                    gleam@result:'try'(
                        decode_to_int(erlang:element(2, R@3)),
                        fun(L) ->
                            gleam@result:'try'(
                                read_some_bytes(erlang:element(3, R@3), L),
                                fun(R@4) ->
                                    case erlang:element(2, Decoder) =:= len of
                                        true ->
                                            gleam@result:'try'(
                                                (erlang:element(3, Decoder))(
                                                    erlang:element(2, R@4)
                                                ),
                                                fun(V) ->
                                                    {ok,
                                                        {[V],
                                                            erlang:element(
                                                                3,
                                                                R@4
                                                            )}}
                                                end
                                            );

                                        false ->
                                            gleam@result:'try'(
                                                decode_packed_numbers(
                                                    erlang:element(2, R@4),
                                                    Decoder,
                                                    []
                                                ),
                                                fun(Numbers) ->
                                                    {ok,
                                                        {lists:reverse(Numbers),
                                                            erlang:element(
                                                                3,
                                                                R@4
                                                            )}}
                                                end
                                            )
                                    end
                                end
                            )
                        end
                    )
                end
            )
    end.

-file("/Users/windy/mygleam/acrostic/src/acrostic/decoding.gleam", 13).
-spec read_key(bitstring()) -> {ok, {key(), bitstring()}} | {error, binary()}.
read_key(Binary) ->
    gleam@result:'try'(
        read_varint_bytes(Binary),
        fun(R) ->
            gleam@result:'try'(
                decode_to_int(erlang:element(2, R)),
                fun(N) ->
                    Wire_type = erlang:'band'(N, 2#111),
                    Field_number = erlang:'bsr'(N - Wire_type, 3),
                    gleam@result:'try'(
                        acrostic@wire:from_int(Wire_type),
                        fun(Wire_type@1) ->
                            {ok,
                                {{key, Field_number, Wire_type@1},
                                    erlang:element(3, R)}}
                        end
                    )
                end
            )
        end
    ).