radish

-module(radish@decoder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function]).

-export([decode/1]).

-spec consume_till_crlf(bitstring(), bitstring()) -> {ok,
        {bitstring(), bitstring()}} |
    {error, nil}.
consume_till_crlf(Data, Storage) ->
    case erlang:byte_size(Data) of
        0 ->
            {error, nil};

        _ ->
            case Data of
                <<"\r\n"/utf8, Rest/bitstring>> ->
                    {ok, {Storage, Rest}};

                <<Ch:8, Rest@1/bitstring>> ->
                    consume_till_crlf(
                        Rest@1,
                        gleam@bit_array:append(Storage, <<Ch>>)
                    )
            end
    end.

-spec consume_by_length(bitstring(), integer(), bitstring()) -> {ok,
        {bitstring(), bitstring()}} |
    {error, nil}.
consume_by_length(Data, Length, Storage) ->
    case erlang:byte_size(Data) of
        0 ->
            {error, nil};

        _ ->
            <<Ch:8, Rest/bitstring>> = Data,
            case erlang:byte_size(Storage) =:= Length of
                true ->
                    {ok, {gleam@bit_array:append(Storage, <<Ch>>), Rest}};

                false ->
                    consume_by_length(
                        Rest,
                        Length,
                        gleam@bit_array:append(Storage, <<Ch>>)
                    )
            end
    end.

-spec decode_array(bitstring(), integer(), list(radish@resp:value())) -> {ok,
        {list(radish@resp:value()), bitstring()}} |
    {error, nil}.
decode_array(Data, Length, Storage) ->
    case gleam@list:length(Storage) =:= Length of
        true ->
            {ok, {Storage, Data}};

        false ->
            gleam@result:then(
                decode_message(Data),
                fun(_use0) ->
                    {Item, Rest} = _use0,
                    decode_array(
                        Rest,
                        Length,
                        gleam@list:append(Storage, [Item])
                    )
                end
            )
    end.

-spec decode_message(bitstring()) -> {ok, {radish@resp:value(), bitstring()}} |
    {error, nil}.
decode_message(Value) ->
    case Value of
        <<>> ->
            {error, nil};

        <<"_\r\n"/utf8, Rest/bitstring>> ->
            {ok, {null, Rest}};

        <<",nan\r\n"/utf8, Rest@1/bitstring>> ->
            {ok, {nan, Rest@1}};

        <<",inf\r\n"/utf8, Rest@2/bitstring>> ->
            {ok, {infinity, Rest@2}};

        <<"#t\r\n"/utf8, Rest@3/bitstring>> ->
            {ok, {{boolean, true}, Rest@3}};

        <<"#f\r\n"/utf8, Rest@4/bitstring>> ->
            {ok, {{boolean, false}, Rest@4}};

        <<",-inf\r\n"/utf8, Rest@5/bitstring>> ->
            {ok, {negative_infinity, Rest@5}};

        <<":"/utf8, Rest@6/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@6, <<>>),
                fun(_use0) ->
                    {Value@1, Rest@7} = _use0,
                    gleam@result:then(
                        gleam@bit_array:to_string(Value@1),
                        fun(Value@2) -> _pipe = Value@2,
                            _pipe@1 = gleam@int:parse(_pipe),
                            _pipe@2 = gleam@result:map(
                                _pipe@1,
                                fun(Field@0) -> {integer, Field@0} end
                            ),
                            gleam@result:map(
                                _pipe@2,
                                fun(Value@3) -> {Value@3, Rest@7} end
                            ) end
                    )
                end
            );

        <<","/utf8, Rest@8/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@8, <<>>),
                fun(_use0@1) ->
                    {Value@4, Rest@9} = _use0@1,
                    gleam@result:then(
                        gleam@bit_array:to_string(Value@4),
                        fun(Value@5) -> case gleam@int:parse(Value@5) of
                                {ok, Value@6} ->
                                    _pipe@5 = {begin
                                            _pipe@3 = Value@6,
                                            _pipe@4 = gleam@int:to_float(
                                                _pipe@3
                                            ),
                                            {double, _pipe@4}
                                        end,
                                        Rest@9},
                                    {ok, _pipe@5};

                                {error, nil} ->
                                    _pipe@6 = Value@5,
                                    _pipe@7 = gleam@float:parse(_pipe@6),
                                    _pipe@8 = gleam@result:map(
                                        _pipe@7,
                                        fun(Field@0) -> {double, Field@0} end
                                    ),
                                    gleam@result:map(
                                        _pipe@8,
                                        fun(Value@7) -> {Value@7, Rest@9} end
                                    )
                            end end
                    )
                end
            );

        <<"+"/utf8, Rest@10/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@10, <<>>),
                fun(_use0@2) ->
                    {Value@8, Rest@11} = _use0@2,
                    gleam@result:then(
                        gleam@bit_array:to_string(Value@8),
                        fun(Value@9) ->
                            _pipe@9 = {{simple_string, Value@9}, Rest@11},
                            {ok, _pipe@9}
                        end
                    )
                end
            );

        <<"-"/utf8, Rest@12/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@12, <<>>),
                fun(_use0@3) ->
                    {Value@10, Rest@13} = _use0@3,
                    gleam@result:then(
                        gleam@bit_array:to_string(Value@10),
                        fun(Value@11) ->
                            _pipe@10 = {{simple_error, Value@11}, Rest@13},
                            {ok, _pipe@10}
                        end
                    )
                end
            );

        <<"("/utf8, Rest@14/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@14, <<>>),
                fun(_use0@4) ->
                    {Value@12, Rest@15} = _use0@4,
                    gleam@result:then(
                        gleam@bit_array:to_string(Value@12),
                        fun(Value@13) -> _pipe@11 = Value@13,
                            _pipe@12 = gleam@int:parse(_pipe@11),
                            _pipe@13 = gleam@result:map(
                                _pipe@12,
                                fun(Field@0) -> {big_number, Field@0} end
                            ),
                            gleam@result:map(
                                _pipe@13,
                                fun(Value@14) -> {Value@14, Rest@15} end
                            ) end
                    )
                end
            );

        <<"$"/utf8, Rest@16/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@16, <<>>),
                fun(_use0@5) ->
                    {Length, Rest@17} = _use0@5,
                    gleam@result:then(
                        gleam@bit_array:to_string(Length),
                        fun(Length@1) ->
                            gleam@result:then(
                                gleam@int:parse(Length@1),
                                fun(Length@2) ->
                                    gleam@result:then(
                                        consume_by_length(
                                            Rest@17,
                                            Length@2 - 1,
                                            <<>>
                                        ),
                                        fun(_use0@6) ->
                                            {Value@15, Rest@18} = _use0@6,
                                            gleam@result:then(
                                                gleam@bit_array:to_string(
                                                    Value@15
                                                ),
                                                fun(Value@16) ->
                                                    <<"\r\n"/utf8,
                                                        Rest@19/bitstring>> = Rest@18,
                                                    _pipe@14 = {{bulk_string,
                                                            Value@16},
                                                        Rest@19},
                                                    {ok, _pipe@14}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"!"/utf8, Rest@20/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@20, <<>>),
                fun(_use0@7) ->
                    {Length@3, Rest@21} = _use0@7,
                    gleam@result:then(
                        gleam@bit_array:to_string(Length@3),
                        fun(Length@4) ->
                            gleam@result:then(
                                gleam@int:parse(Length@4),
                                fun(Length@5) ->
                                    gleam@result:then(
                                        consume_by_length(
                                            Rest@21,
                                            Length@5 - 1,
                                            <<>>
                                        ),
                                        fun(_use0@8) ->
                                            {Value@17, Rest@22} = _use0@8,
                                            gleam@result:then(
                                                gleam@bit_array:to_string(
                                                    Value@17
                                                ),
                                                fun(Value@18) ->
                                                    <<"\r\n"/utf8,
                                                        Rest@23/bitstring>> = Rest@22,
                                                    _pipe@15 = {{bulk_error,
                                                            Value@18},
                                                        Rest@23},
                                                    {ok, _pipe@15}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"*"/utf8, Rest@24/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@24, <<>>),
                fun(_use0@9) ->
                    {Length@6, Rest@25} = _use0@9,
                    gleam@result:then(
                        gleam@bit_array:to_string(Length@6),
                        fun(Length@7) ->
                            gleam@result:then(
                                gleam@int:parse(Length@7),
                                fun(Length@8) ->
                                    gleam@result:then(
                                        decode_array(Rest@25, Length@8, []),
                                        fun(_use0@10) ->
                                            {Value@19, Rest@26} = _use0@10,
                                            _pipe@17 = {begin
                                                    _pipe@16 = Value@19,
                                                    {array, _pipe@16}
                                                end,
                                                Rest@26},
                                            {ok, _pipe@17}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<">"/utf8, Rest@27/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@27, <<>>),
                fun(_use0@11) ->
                    {Length@9, Rest@28} = _use0@11,
                    gleam@result:then(
                        gleam@bit_array:to_string(Length@9),
                        fun(Length@10) ->
                            gleam@result:then(
                                gleam@int:parse(Length@10),
                                fun(Length@11) ->
                                    gleam@result:then(
                                        decode_array(Rest@28, Length@11, []),
                                        fun(_use0@12) ->
                                            {Value@20, Rest@29} = _use0@12,
                                            _pipe@19 = {begin
                                                    _pipe@18 = Value@20,
                                                    {push, _pipe@18}
                                                end,
                                                Rest@29},
                                            {ok, _pipe@19}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"~"/utf8, Rest@30/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@30, <<>>),
                fun(_use0@13) ->
                    {Length@12, Rest@31} = _use0@13,
                    gleam@result:then(
                        gleam@bit_array:to_string(Length@12),
                        fun(Length@13) ->
                            gleam@result:then(
                                gleam@int:parse(Length@13),
                                fun(Length@14) ->
                                    gleam@result:then(
                                        decode_array(Rest@31, Length@14, []),
                                        fun(_use0@14) ->
                                            {Value@21, Rest@32} = _use0@14,
                                            _pipe@22 = {begin
                                                    _pipe@20 = Value@21,
                                                    _pipe@21 = gleam@set:from_list(
                                                        _pipe@20
                                                    ),
                                                    {set, _pipe@21}
                                                end,
                                                Rest@32},
                                            {ok, _pipe@22}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        <<"%"/utf8, Rest@33/bitstring>> ->
            gleam@result:then(
                consume_till_crlf(Rest@33, <<>>),
                fun(_use0@15) ->
                    {Length@15, Rest@34} = _use0@15,
                    gleam@result:then(
                        gleam@bit_array:to_string(Length@15),
                        fun(Length@16) ->
                            gleam@result:then(
                                gleam@int:parse(Length@16),
                                fun(Length@17) ->
                                    gleam@result:then(
                                        decode_map(Rest@34, Length@17, []),
                                        fun(_use0@16) ->
                                            {Value@22, Rest@35} = _use0@16,
                                            _pipe@24 = {begin
                                                    _pipe@23 = Value@22,
                                                    {map, _pipe@23}
                                                end,
                                                Rest@35},
                                            {ok, _pipe@24}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
    end.

-spec decode_multiple(bitstring(), list(radish@resp:value())) -> {ok,
        list(radish@resp:value())} |
    {error, radish@error:error()}.
decode_multiple(Value, Storage) ->
    _pipe = decode_message(Value),
    _pipe@1 = gleam@result:map(
        _pipe,
        fun(Value@1) ->
            Storage@1 = gleam@list:append(Storage, [erlang:element(1, Value@1)]),
            case Value@1 of
                {_, <<>>} ->
                    {ok, Storage@1};

                {_, Rest} ->
                    decode_multiple(Rest, Storage@1)
            end
        end
    ),
    _pipe@2 = gleam@result:replace_error(_pipe@1, resp_error),
    gleam@result:flatten(_pipe@2).

-spec decode(bitstring()) -> {ok, list(radish@resp:value())} |
    {error, radish@error:error()}.
decode(Value) ->
    _pipe = decode_multiple(Value, []),
    gleam@result:replace_error(_pipe, resp_error).

-spec decode_map(
    bitstring(),
    integer(),
    list({radish@resp:value(), radish@resp:value()})
) -> {ok, {list({radish@resp:value(), radish@resp:value()}), bitstring()}} |
    {error, nil}.
decode_map(Data, Length, Storage) ->
    case gleam@list:length(Storage) =:= Length of
        true ->
            {ok, {Storage, Data}};

        false ->
            gleam@result:then(
                decode_message(Data),
                fun(_use0) ->
                    {Key, Rest} = _use0,
                    gleam@result:then(
                        decode_message(Rest),
                        fun(_use0@1) ->
                            {Value, Rest@1} = _use0@1,
                            decode_map(
                                Rest@1,
                                Length,
                                gleam@list:append(Storage, [{Key, Value}])
                            )
                        end
                    )
                end
            )
    end.