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

-export([get_json_serializer_str/1, from/1]).
-export_type([stmt_gen_req/0]).

-type stmt_gen_req() :: {stmt,
        internal@codegen@types:gleam_type(),
        binary(),
        list(binary())}.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 18).
-spec request_basic_stmt(internal@codegen@types:gleam_type()) -> stmt_gen_req().
request_basic_stmt(T) ->
    {stmt, T, <<""/utf8>>, []}.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 22).
-spec request_stmt(
    internal@codegen@types:gleam_type(),
    binary(),
    list(binary())
) -> stmt_gen_req().
request_stmt(T, Mq, Imps) ->
    {stmt, T, Mq, Imps}.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 26).
-spec glance_t_to_codegen_t(glance:type(), request:request()) -> stmt_gen_req().
glance_t_to_codegen_t(X, Req) ->
    case X of
        {named_type, Name, Module, 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/serializer"/utf8>>,
                                        function => <<"glance_t_to_codegen_t"/utf8>>,
                                        line => 31})
                    end,
                    request_basic_stmt(
                        {list_type,
                            erlang:element(2, glance_t_to_codegen_t(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/serializer"/utf8>>,
                                        function => <<"glance_t_to_codegen_t"/utf8>>,
                                        line => 36})
                    end,
                    request_basic_stmt(
                        internal@codegen@types:option(
                            erlang:element(2, glance_t_to_codegen_t(T0@1, Req))
                        )
                    );

                <<"Result"/utf8>> ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"Result is unimplemented! serde-style tagging support needed https://serde.rs/enum-representations.html"/utf8>>,
                            module => <<"internal/serializer"/utf8>>,
                            function => <<"glance_t_to_codegen_t"/utf8>>,
                            line => 41});

                _ ->
                    case Module of
                        none ->
                            request_basic_stmt({anonymous_type, Name});

                        {some, Module_str} ->
                            Type_import_string = ast:get_import_path_from_mod_name(
                                Module_str,
                                Req
                            ),
                            request_stmt(
                                {anonymous_type,
                                    <<Module_str/binary, "_json"/utf8>>},
                                <<Module_str/binary, "_json.to_json"/utf8>>,
                                [<<Type_import_string/binary, "_json"/utf8>>]
                            )
                    end
            end;

        {tuple_type, Elements} ->
            request_basic_stmt(
                {tuple_type,
                    gleam@list:map(
                        Elements,
                        fun(El) ->
                            erlang:element(2, glance_t_to_codegen_t(El, Req))
                        end
                    )}
            );

        {function_type, _, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"cannot serialize entities with functions"/utf8>>,
                    module => <<"internal/serializer"/utf8>>,
                    function => <<"glance_t_to_codegen_t"/utf8>>,
                    line => 70});

        {variable_type, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unimplemented! VariableType"/utf8>>,
                    module => <<"internal/serializer"/utf8>>,
                    function => <<"glance_t_to_codegen_t"/utf8>>,
                    line => 74});

        {hole_type, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unimplemented! HoleType"/utf8>>,
                    module => <<"internal/serializer"/utf8>>,
                    function => <<"glance_t_to_codegen_t"/utf8>>,
                    line => 77})
    end.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 82).
-spec get_json_serializer_str(internal@codegen@types:gleam_type()) -> binary().
get_json_serializer_str(Ct) ->
    case Ct of
        {anonymous_type, Name} ->
            <<"json."/utf8, (string:lowercase(Name))/binary>>;

        {tuple_type, _} ->
            <<"json.preprocessed_array"/utf8>>;

        {list_type, _} ->
            <<"json.array"/utf8>>;

        {variant_dep_type, Name@1, _, _} ->
            case Name@1 of
                <<"Option"/utf8>> ->
                    <<"json.nullable"/utf8>>;

                _ ->
                    <<(erlang:error(#{gleam_error => panic,
                                message => <<"VariantDefType not supported: "/utf8>>,
                                module => <<"internal/serializer"/utf8>>,
                                function => <<"get_json_serializer_str"/utf8>>,
                                line => 95}))/binary, Name@1/binary>>
            end;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unimplemented! get_json_serializer_str"/utf8>>,
                    module => <<"internal/serializer"/utf8>>,
                    function => <<"get_json_serializer_str"/utf8>>,
                    line => 100})
    end.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 105).
-spec codegen_t_to_codegen_json_t(stmt_gen_req(), binary()) -> internal@codegen@statements:gleam_statement().
codegen_t_to_codegen_json_t(Gen, Field_name) ->
    {stmt, Gt, Module_path, _} = Gen,
    Json_call_fn_str = get_json_serializer_str(Gt),
    Field_name_var = {var_primitive, <<"t."/utf8, Field_name/binary>>},
    case Gt of
        {anonymous_type, _} ->
            case Module_path of
                <<""/utf8>> ->
                    internal@codegen@statements:call(
                        Json_call_fn_str,
                        [Field_name_var]
                    );

                Mq ->
                    internal@codegen@statements:call(Mq, [Field_name_var])
            end;

        {tuple_type, Els} ->
            internal@codegen@statements:call(
                Json_call_fn_str,
                [internal@codegen@statements:list(
                        gleam@list:index_map(
                            Els,
                            fun(El, I) ->
                                codegen_t_to_codegen_json_t(
                                    request_basic_stmt(El),
                                    <<<<Field_name/binary, "."/utf8>>/binary,
                                        (erlang:integer_to_binary(I))/binary>>
                                )
                            end
                        )
                    )]
            );

        {list_type, Inner} ->
            internal@codegen@statements:call(
                Json_call_fn_str,
                [Field_name_var,
                    {var_primitive, get_json_serializer_str(Inner)}]
            );

        {variant_dep_type, _, Dep_types, _} ->
            internal@codegen@statements:call(
                Json_call_fn_str,
                [Field_name_var |
                    gleam@list:map(
                        Dep_types,
                        fun(Inner@1) ->
                            {var_primitive, get_json_serializer_str(Inner@1)}
                        end
                    )]
            );

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"unimplemented! codegen_t_to_codegen_json_t"/utf8>>,
                    module => <<"internal/serializer"/utf8>>,
                    function => <<"codegen_t_to_codegen_json_t"/utf8>>,
                    line => 143})
    end.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 149).
-spec serializer_of_t(glance:type(), binary(), request:request()) -> {stmt_gen_req(),
    internal@codegen@statements:gleam_statement()}.
serializer_of_t(X, Field_name, Req) ->
    Gen_req = glance_t_to_codegen_t(X, Req),
    {Gen_req, codegen_t_to_codegen_json_t(Gen_req, Field_name)}.

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 154).
-spec gen_to_json(request:request()) -> internal@codegen@modules:mod().
gen_to_json(Req) ->
    {request, Src_module_name, Type_name, _, Variant, _, _} = Req,
    {Required_imports, Field_serializers} = gleam@list:fold(
        erlang:element(3, Variant),
        {[], []},
        fun(Acc, Field) ->
            Label = begin
                _pipe = gleam@option:to_result(erlang:element(2, Field), nil),
                evil:expect(
                    _pipe,
                    <<<<"Variant "/utf8, (erlang:element(2, Variant))/binary>>/binary,
                        " must have labels for all fields"/utf8>>
                )
            end,
            {Gen_req, Serializer} = serializer_of_t(
                erlang:element(3, Field),
                Label,
                Req
            ),
            {gleam@list:concat(
                    [erlang:element(1, Acc), erlang:element(4, Gen_req)]
                ),
                gleam@list:concat(
                    [erlang:element(2, Acc),
                        [{tuple_val, [{string_val, Label}, Serializer]}]]
                )}
        end
    ),
    _pipe@1 = internal@codegen@modules:empty(),
    _pipe@2 = internal@codegen@modules:add_imports(_pipe@1, Required_imports),
    internal@codegen@modules:add_functions(
        _pipe@2,
        [{function,
                <<"to_json"/utf8>>,
                [internal@codegen@statements:arg_typed(
                        <<"t"/utf8>>,
                        {anonymous_type,
                            <<<<(internal@path:basename(Src_module_name))/binary,
                                    "."/utf8>>/binary,
                                Type_name/binary>>}
                    )],
                [internal@codegen@statements:call(
                        <<"json.object"/utf8>>,
                        [internal@codegen@statements:list(Field_serializers)]
                    )]}]
    ).

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 198).
-spec gen_to_string(request:request()) -> internal@codegen@modules:mod().
gen_to_string(Req) ->
    {request, Src_module_name, Type_name, _, _, _, _} = Req,
    _pipe = internal@codegen@modules:empty(),
    internal@codegen@modules:add_functions(
        _pipe,
        [{function,
                <<"to_string"/utf8>>,
                [internal@codegen@statements:arg_typed(
                        <<"t"/utf8>>,
                        {anonymous_type,
                            <<<<(internal@path:basename(Src_module_name))/binary,
                                    "."/utf8>>/binary,
                                Type_name/binary>>}
                    )],
                [internal@codegen@statements:call(
                        <<"json.to_string"/utf8>>,
                        [internal@codegen@statements:call(
                                <<"to_json"/utf8>>,
                                [internal@codegen@statements:variable(
                                        <<"t"/utf8>>
                                    )]
                            )]
                    )]}]
    ).

-file("/Users/cdaringe/src/gserde/src/internal/serializer.gleam", 217).
-spec from(request:request()) -> binary().
from(Req) ->
    _pipe = internal@codegen@modules:merge(gen_to_json(Req), gen_to_string(Req)),
    internal@codegen@modules:to_string(_pipe).