gserde

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

-export([to/1]).

-spec quote(binary()) -> binary().
quote(Str) ->
    <<<<"\""/utf8, Str/binary>>/binary, "\""/utf8>>.

-spec gen_decoder(glance:type()) -> internal@codegen@statements:gleam_statement().
gen_decoder(Typ) ->
    case Typ of
        {named_type, Name, _, Parameters} ->
            case Name of
                <<"List"/utf8>> ->
                    _assert_subject = gleam@list:at(Parameters, 0),
                    {ok, T0} = case _assert_subject of
                        {ok, _} -> _assert_subject;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Assertion pattern match failed"/utf8>>,
                                        value => _assert_fail,
                                        module => <<"deserializer"/utf8>>,
                                        function => <<"gen_decoder"/utf8>>,
                                        line => 21})
                    end,
                    internal@codegen@statements:call(
                        <<"dynamic.list"/utf8>>,
                        [gen_decoder(T0)]
                    );

                <<"Option"/utf8>> ->
                    _assert_subject@1 = gleam@list: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 => <<"Assertion pattern match failed"/utf8>>,
                                        value => _assert_fail@1,
                                        module => <<"deserializer"/utf8>>,
                                        function => <<"gen_decoder"/utf8>>,
                                        line => 25})
                    end,
                    internal@codegen@statements:call(
                        <<"dynamic.optional"/utf8>>,
                        [gen_decoder(T0@1)]
                    );

                _ ->
                    {var_primitive,
                        <<"dynamic."/utf8,
                            (gleam@string:lowercase(Name))/binary>>}
            end;

        {tuple_type, Parts} ->
            M_tuple = begin
                _pipe = gleam@list:length(Parts),
                gleam@int:to_string(_pipe)
            end,
            internal@codegen@statements:call(
                <<"dynamic.tuple"/utf8,
                    (gleam@string:lowercase(M_tuple))/binary>>,
                begin
                    _pipe@1 = Parts,
                    gleam@list:map(_pipe@1, fun gen_decoder/1)
                end
            );

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

-spec gen_root_decoder(request:request()) -> internal@codegen@statements:gleam_statement().
gen_root_decoder(Req) ->
    {request, Src_module_name, _, Variant, _, _} = Req,
    N_str = begin
        _pipe = gleam@list:length(erlang:element(3, Variant)),
        gleam@int:to_string(_pipe)
    end,
    {function,
        <<"from_json"/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(
                        <<"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(4, Req)),
                                fun(Field) ->
                                    internal@codegen@statements:call(
                                        <<"dynamic.field"/utf8>>,
                                        [{var_primitive,
                                                begin
                                                    _pipe@1 = gleam@option:lazy_unwrap(
                                                        erlang:element(2, Field),
                                                        fun() ->
                                                            erlang:error(
                                                                #{gleam_error => panic,
                                                                    message => <<"@todo/panic variants must be labeled"/utf8>>,
                                                                    module => <<"deserializer"/utf8>>,
                                                                    function => <<"gen_root_decoder"/utf8>>,
                                                                    line => 70}
                                                            )
                                                        end
                                                    ),
                                                    quote(_pipe@1)
                                                end},
                                            gen_decoder(
                                                erlang:element(3, Field)
                                            )]
                                    )
                                end
                            )]
                    )]
            )]}.

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