-module(aide@generator).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/aide/generator.gleam").
-export([generate/1]).

-file("src/aide/generator.gleam", 14).
-spec to_schema(
    list({binary(), oas@json_schema:ref(oas@json_schema:schema()), boolean()})
) -> oas@json_schema:schema().
to_schema(Fields) ->
    oas@json_schema:object(Fields).

-file("src/aide/generator.gleam", 56).
-spec defs(list(WWK)) -> list(glance:definition(WWK)).
defs(Xs) ->
    gleam@list:map(Xs, fun(_capture) -> {definition, [], _capture} end).

-file("src/aide/generator.gleam", 60).
-spec name_fn(list(binary())) -> glance:function_().
name_fn(Tools) ->
    {function,
        <<"call_name"/utf8>>,
        public,
        [{function_parameter, none, {named, <<"call"/utf8>>}, none}],
        none,
        [{expression,
                {'case',
                    [{variable, <<"call"/utf8>>}],
                    gleam@list:map(
                        Tools,
                        fun(Tool) ->
                            {clause,
                                [[{pattern_constructor,
                                            none,
                                            oas@generator@ast:name_for_gleam_type(
                                                Tool
                                            ),
                                            [],
                                            true}]],
                                none,
                                {string, Tool}}
                        end
                    )}}],
        {span, 0, 0}}.

-file("src/aide/generator.gleam", 97).
-spec encode_fn(list(binary())) -> glance:function_().
encode_fn(Tools) ->
    {function,
        <<"call_encode"/utf8>>,
        public,
        [{function_parameter, none, {named, <<"call"/utf8>>}, none}],
        none,
        [{expression,
                {'case',
                    [{variable, <<"call"/utf8>>}],
                    gleam@list:map(
                        Tools,
                        fun(Tool) ->
                            {clause,
                                [[{pattern_constructor,
                                            none,
                                            oas@generator@ast:name_for_gleam_type(
                                                Tool
                                            ),
                                            [{shorthand_field, <<"input"/utf8>>}],
                                            true}]],
                                none,
                                {call,
                                    {variable,
                                        oas@generator@ast:name_for_gleam_field_or_var(
                                            <<Tool/binary,
                                                "_input_encode"/utf8>>
                                        )},
                                    [{unlabelled_field,
                                            {variable, <<"input"/utf8>>}}]}}
                        end
                    )}}],
        {span, 0, 0}}.

-file("src/aide/generator.gleam", 141).
-spec collective_type(list(binary())) -> glance:custom_type().
collective_type(Tools) ->
    {custom_type,
        <<"Call"/utf8>>,
        public,
        false,
        [],
        gleam@list:map(
            Tools,
            fun(Tool) ->
                {variant,
                    oas@generator@ast:name_for_gleam_type(Tool),
                    [{labelled_variant_field,
                            {named_type,
                                oas@generator@ast:name_for_gleam_type(
                                    <<Tool/binary, "_input"/utf8>>
                                ),
                                none,
                                []},
                            <<"input"/utf8>>},
                        {labelled_variant_field,
                            {function_type,
                                [{named_type,
                                        oas@generator@ast:name_for_gleam_type(
                                            <<Tool/binary, "_output"/utf8>>
                                        ),
                                        none,
                                        []}],
                                {named_type,
                                    <<"Dict"/utf8>>,
                                    {some, <<"dict"/utf8>>},
                                    [{named_type, <<"String"/utf8>>, none, []},
                                        {named_type,
                                            <<"Any"/utf8>>,
                                            {some, <<"utils"/utf8>>},
                                            []}]}},
                            <<"cast"/utf8>>}]}
            end
        )}.

-file("src/aide/generator.gleam", 18).
-spec generate(list(aide@tool:spec())) -> binary().
generate(Tools) ->
    {Tools@1, Specs} = begin
        _pipe@2 = gleam@list:map(
            Tools,
            fun(Tool) ->
                {spec, Name, Input, Output} = Tool,
                {Name,
                    [{<<Name/binary, "_input"/utf8>>,
                            begin
                                _pipe = Input,
                                to_schema(_pipe)
                            end},
                        {<<Name/binary, "_output"/utf8>>,
                            begin
                                _pipe@1 = Output,
                                to_schema(_pipe@1)
                            end}]}
            end
        ),
        gleam@list:unzip(_pipe@2)
    end,
    {Custom@1, Fns@1} = case begin
        _pipe@5 = oas@generator@schema:generate(
            begin
                _pipe@3 = Specs,
                _pipe@4 = lists:append(_pipe@3),
                maps:from_list(_pipe@4)
            end
        ),
        oas@generator:run_single_location(_pipe@5, <<"#"/utf8>>)
    end of
        {ok, {Custom, _, Fns}} -> {Custom, Fns};
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"aide/generator"/utf8>>,
                        function => <<"generate"/utf8>>,
                        line => 28,
                        value => _assert_fail,
                        start => 664,
                        'end' => 806,
                        pattern_start => 675,
                        pattern_end => 701})
    end,
    Imports = begin
        _pipe@6 = [{import, <<"gleam/dynamic/decode"/utf8>>, none, [], []},
            {import, <<"gleam/dict"/utf8>>, none, [], []},
            {import, <<"gleam/json"/utf8>>, none, [], []},
            {import,
                <<"gleam/option"/utf8>>,
                none,
                [{unqualified_import, <<"Option"/utf8>>, none}],
                [{unqualified_import, <<"None"/utf8>>, none}]},
            {import, <<"oas/generator/utils"/utf8>>, none, [], []}],
        lists:reverse(_pipe@6)
    end,
    _pipe@8 = {module,
        defs(Imports),
        defs(
            begin
                _pipe@7 = Custom@1,
                lists:append(_pipe@7, [collective_type(Tools@1)])
            end
        ),
        [],
        [],
        defs(lists:append(Fns@1, [name_fn(Tools@1), encode_fn(Tools@1)]))},
    glance_printer:print(_pipe@8).