gserde

-module(internal@deserializer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/deserializer.gleam").
-export([to/1]).

-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).

-file("src/internal/deserializer.gleam", 13).
?DOC(false).
-spec quote(binary()) -> binary().
quote(Str) ->
    <<<<"\""/utf8, Str/binary>>/binary, "\""/utf8>>.

-file("src/internal/deserializer.gleam", 17).
?DOC(false).
-spec gen_decoder(glance:type()) -> internal@codegen@statements:gleam_statement().
gen_decoder(Typ) ->
    case Typ of
        {named_type, _, Name, Module, Parameters} ->
            case Name of
                <<"List"/utf8>> ->
                    T0@1 = case gleam@list:first(Parameters) of
                        {ok, T0} -> T0;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"internal/deserializer"/utf8>>,
                                        function => <<"gen_decoder"/utf8>>,
                                        line => 22,
                                        value => _assert_fail,
                                        start => 476,
                                        'end' => 518,
                                        pattern_start => 487,
                                        pattern_end => 493})
                    end,
                    internal@codegen@statements:call(
                        <<"decode.list"/utf8>>,
                        [gen_decoder(T0@1)]
                    );

                <<"Option"/utf8>> ->
                    T0@3 = case gleam@list:first(Parameters) of
                        {ok, T0@2} -> T0@2;
                        _assert_fail@1 ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"internal/deserializer"/utf8>>,
                                        function => <<"gen_decoder"/utf8>>,
                                        line => 26,
                                        value => _assert_fail@1,
                                        start => 615,
                                        'end' => 657,
                                        pattern_start => 626,
                                        pattern_end => 632})
                    end,
                    internal@codegen@statements:call(
                        <<"decode.optional"/utf8>>,
                        [gen_decoder(T0@3)]
                    );

                _ ->
                    case Module of
                        none ->
                            {var_primitive,
                                <<"decode."/utf8,
                                    (string:lowercase(Name))/binary>>};

                        {some, Module_str} ->
                            {var_primitive,
                                <<<<<<Module_str/binary, "_json."/utf8>>/binary,
                                        (common:decoder_name_of_t(Name))/binary>>/binary,
                                    "()"/utf8>>}
                    end
            end;

        {tuple_type, _, Elements} ->
            {block,
                lists:append(
                    [begin
                            _pipe = Elements,
                            gleam@list:index_map(
                                _pipe,
                                fun(Element, I) ->
                                    {use_expr,
                                        <<"el"/utf8,
                                            (erlang:integer_to_binary(I))/binary>>,
                                        internal@codegen@statements:call(
                                            <<"decode.field"/utf8>>,
                                            [{int_val, I}, gen_decoder(Element)]
                                        )}
                                end
                            )
                        end,
                        [internal@codegen@statements:call(
                                <<"decode.success"/utf8>>,
                                [{tuple_val,
                                        begin
                                            _pipe@1 = Elements,
                                            gleam@list:index_map(
                                                _pipe@1,
                                                fun(_, I@1) ->
                                                    {var_primitive,
                                                        <<"el"/utf8,
                                                            (erlang:integer_to_binary(
                                                                I@1
                                                            ))/binary>>}
                                                end
                                            )
                                        end}]
                            )]]
                )};

        X ->
            gleam_stdlib:println_error(
                gleam@string:inspect(
                    {<<"warning: unsupported decoding"/utf8>>, X}
                )
            ),
            {direct, <<"todo"/utf8>>}
    end.

-file("src/internal/deserializer.gleam", 74).
?DOC(false).
-spec gen_root_decoder(request:request()) -> list(internal@codegen@statements:gleam_statement()).
gen_root_decoder(Req) ->
    {request, Src_module_name, Type_name, _, Variant, _, _} = Req,
    Decoder_fn_name = common:decoder_name_of_t(Type_name),
    [{function,
            Decoder_fn_name,
            [],
            lists:append(
                [gleam@list:map(
                        erlang:element(3, erlang:element(5, Req)),
                        fun(Field) -> case Field of
                                {labelled_variant_field, _, Label} ->
                                    {use_expr,
                                        Label,
                                        internal@codegen@statements:call(
                                            <<"decode.field"/utf8>>,
                                            [{var_primitive, quote(Label)},
                                                gen_decoder(
                                                    erlang:element(2, Field)
                                                )]
                                        )};

                                {unlabelled_variant_field, _} ->
                                    erlang:error(#{gleam_error => panic,
                                            message => <<"variants must be labelled"/utf8>>,
                                            file => <<?FILEPATH/utf8>>,
                                            module => <<"internal/deserializer"/utf8>>,
                                            function => <<"gen_root_decoder"/utf8>>,
                                            line => 101})
                            end end
                    ),
                    [internal@codegen@statements:call(
                            <<"decode.success"/utf8>>,
                            [internal@codegen@statements:call(
                                    <<<<(internal@path:basename(Src_module_name))/binary,
                                            "."/utf8>>/binary,
                                        (erlang:element(2, Variant))/binary>>,
                                    gleam@list:map(
                                        erlang:element(
                                            3,
                                            erlang:element(5, Req)
                                        ),
                                        fun(Field@1) -> case Field@1 of
                                                {labelled_variant_field,
                                                    _,
                                                    Label@1} ->
                                                    {var_primitive, Label@1};

                                                {unlabelled_variant_field, _} ->
                                                    erlang:error(
                                                        #{gleam_error => panic,
                                                            message => <<"variants must be labelled"/utf8>>,
                                                            file => <<?FILEPATH/utf8>>,
                                                            module => <<"internal/deserializer"/utf8>>,
                                                            function => <<"gen_root_decoder"/utf8>>,
                                                            line => 113}
                                                    )
                                            end end
                                    )
                                )]
                        )]]
            )},
        {function,
            <<"from_string"/utf8>>,
            [internal@codegen@statements:arg_typed(
                    <<"json_str"/utf8>>,
                    {anonymous_type, <<"String"/utf8>>}
                )],
            [internal@codegen@statements:call(
                    <<"json.parse"/utf8>>,
                    [{var_primitive, <<"json_str"/utf8>>},
                        internal@codegen@statements:call(Decoder_fn_name, [])]
                )]}].

-file("src/internal/deserializer.gleam", 134).
?DOC(false).
-spec to(request:request()) -> binary().
to(Req) ->
    _pipe = gen_root_decoder(Req),
    _pipe@1 = gleam@list:map(_pipe, fun internal@codegen@statements:generate/1),
    gleam@string:join(_pipe@1, <<"\n"/utf8>>).