gserde

-module(internal@deserializer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to/1]).

-file("/Users/cdaringe/src/gserde/src/internal/deserializer.gleam", 14).
-spec quote(binary()) -> binary().
quote(Str) ->
    <<<<"\""/utf8, Str/binary>>/binary, "\""/utf8>>.

-file("/Users/cdaringe/src/gserde/src/internal/deserializer.gleam", 18).
-spec gen_decoder(glance:type(), request:request()) -> internal@codegen@statements:gleam_statement().
gen_decoder(Typ, Req) ->
    case Typ of
        {named_type, Name, Module_name, Parameters} ->
            case Name of
                <<"List"/utf8>> ->
                    _assert_subject = evil:at(Parameters, 0),
                    {ok, T0} = case _assert_subject of
                        {ok, _} -> _assert_subject;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        value => _assert_fail,
                                        module => <<"internal/deserializer"/utf8>>,
                                        function => <<"gen_decoder"/utf8>>,
                                        line => 23})
                    end,
                    internal@codegen@statements:call(
                        <<"dynamic.list"/utf8>>,
                        [gen_decoder(T0, Req)]
                    );

                <<"Option"/utf8>> ->
                    _assert_subject@1 = evil:at(Parameters, 0),
                    {ok, T0@1} = case _assert_subject@1 of
                        {ok, _} -> _assert_subject@1;
                        _assert_fail@1 ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        value => _assert_fail@1,
                                        module => <<"internal/deserializer"/utf8>>,
                                        function => <<"gen_decoder"/utf8>>,
                                        line => 27})
                    end,
                    internal@codegen@statements:call(
                        <<"dynamic.optional"/utf8>>,
                        [gen_decoder(T0@1, Req)]
                    );

                _ ->
                    case Module_name of
                        none ->
                            {var_primitive,
                                <<"dynamic."/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, Parts} ->
            M_tuple = begin
                _pipe = erlang:length(Parts),
                erlang:integer_to_binary(_pipe)
            end,
            internal@codegen@statements:call(
                <<"dynamic.tuple"/utf8, (string:lowercase(M_tuple))/binary>>,
                begin
                    _pipe@1 = Parts,
                    gleam@list:map(
                        _pipe@1,
                        fun(Part) -> gen_decoder(Part, Req) end
                    )
                end
            );

        X ->
            gleam@io:debug({<<"warning: unsupported decoding"/utf8>>, X}),
            {var_primitive, <<"dynamic.toodoo"/utf8>>}
    end.

-file("/Users/cdaringe/src/gserde/src/internal/deserializer.gleam", 61).
-spec gen_root_decoder(request:request()) -> list(internal@codegen@statements:gleam_statement()).
gen_root_decoder(Req) ->
    {request, Src_module_name, Type_name, _, Variant, _, _} = Req,
    N_str = begin
        _pipe = erlang:length(erlang:element(3, Variant)),
        erlang:integer_to_binary(_pipe)
    end,
    Decoder_fn_name = common:decoder_name_of_t(Type_name),
    [{function,
            Decoder_fn_name,
            [],
            [internal@codegen@statements:call(
                    <<"dynamic.decode"/utf8, N_str/binary>>,
                    [{var_primitive,
                            <<<<(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) ->
                                internal@codegen@statements:call(
                                    <<"dynamic.field"/utf8>>,
                                    [{var_primitive,
                                            begin
                                                _pipe@1 = gleam@option:to_result(
                                                    erlang:element(2, Field),
                                                    nil
                                                ),
                                                _pipe@2 = evil:expect(
                                                    _pipe@1,
                                                    <<"@todo/panic variants must be labeled"/utf8>>
                                                ),
                                                quote(_pipe@2)
                                            end},
                                        gen_decoder(
                                            erlang:element(3, Field),
                                            Req
                                        )]
                                )
                            end
                        )]
                )]},
        {function,
            <<"from_string"/utf8>>,
            [internal@codegen@statements:arg_typed(
                    <<"json_str"/utf8>>,
                    {anonymous_type, <<"String"/utf8>>}
                )],
            [internal@codegen@statements:call(
                    <<"json.decode"/utf8>>,
                    [{var_primitive, <<"json_str"/utf8>>},
                        internal@codegen@statements:call(Decoder_fn_name, [])]
                )]}].

-file("/Users/cdaringe/src/gserde/src/internal/deserializer.gleam", 103).
-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>>).