-module(roundabout@generate_types).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/roundabout/generate_types.gleam").
-export([generate_type/2, generate_type_rec/2]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-file("src/roundabout/generate_types.gleam", 96).
-spec generate_type_variant_param(roundabout@node:segment()) -> {ok, binary()} |
    {error, nil}.
generate_type_variant_param(Segment) ->
    case Segment of
        {seg_param, Param} ->
            {ok, roundabout@parameter:full(Param)};

        {seg_lit, _} ->
            {error, nil}
    end.

-file("src/roundabout/generate_types.gleam", 103).
-spec get_route_name(list(roundabout@node:info()), roundabout@node:info()) -> binary().
get_route_name(Ancestors, Info) ->
    <<(roundabout@common:get_type_name(Ancestors, Info))/binary, "Route"/utf8>>.

-file("src/roundabout/generate_types.gleam", 70).
?DOC(
    " Generate one type variant e.g.\n"
    "\n"
    " ```\n"
    "   User(user_id: Int, sub: UserRoute)\n"
    " ```\n"
).
-spec generate_type_variant(
    list(roundabout@node:info()),
    roundabout@node:node_()
) -> glam@doc:document().
generate_type_variant(Ancestors, Node) ->
    Type_name = roundabout@common:get_type_name(
        Ancestors,
        erlang:element(2, Node)
    ),
    Sub = case gleam@list:is_empty(erlang:element(3, Node)) of
        true ->
            none;

        false ->
            {some,
                <<"sub: "/utf8,
                    (get_route_name(Ancestors, erlang:element(2, Node)))/binary>>}
    end,
    Params = begin
        _pipe = erlang:element(3, erlang:element(2, Node)),
        _pipe@1 = gleam@list:filter_map(
            _pipe,
            fun generate_type_variant_param/1
        ),
        (fun(Items) -> case Sub of
                none ->
                    Items;

                {some, Sub@1} ->
                    lists:append(Items, [Sub@1])
            end end)(_pipe@1)
    end,
    Params@1 = case gleam@list:is_empty(Params) of
        true ->
            <<""/utf8>>;

        false ->
            <<<<"("/utf8, (gleam@string:join(Params, <<", "/utf8>>))/binary>>/binary,
                ")"/utf8>>
    end,
    glam@doc:from_string(<<Type_name/binary, Params@1/binary>>).

-file("src/roundabout/generate_types.gleam", 40).
?DOC(false).
-spec generate_type(list(roundabout@node:info()), roundabout@node:node_()) -> glam@doc:document().
generate_type(Ancestors, Node) ->
    Next_ancestors = gleam@list:prepend(Ancestors, erlang:element(2, Node)),
    Variants = begin
        _pipe = erlang:element(3, Node),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(_capture) -> generate_type_variant(Next_ancestors, _capture) end
        ),
        glam@doc:join(_pipe@1, {line, 1})
    end,
    Route_name = get_route_name(Ancestors, erlang:element(2, Node)),
    glam@doc:concat(
        [glam@doc:from_string(
                <<<<"pub type "/utf8, Route_name/binary>>/binary, " {"/utf8>>
            ),
            glam@doc:nest_docs([{line, 1}, Variants], 2),
            {line, 1},
            glam@doc:from_string(<<"}"/utf8>>),
            glam@doc:lines(2)]
    ).

-file("src/roundabout/generate_types.gleam", 22).
?DOC(false).
-spec generate_type_rec(list(roundabout@node:info()), roundabout@node:node_()) -> glam@doc:document().
generate_type_rec(Ancestors, Node) ->
    case gleam@list:is_empty(erlang:element(3, Node)) of
        true ->
            glam@doc:from_string(<<""/utf8>>);

        false ->
            Next_ancestors = gleam@list:prepend(
                Ancestors,
                erlang:element(2, Node)
            ),
            Sub_types = begin
                _pipe = erlang:element(3, Node),
                gleam@list:map(
                    _pipe,
                    fun(Node@1) -> generate_type_rec(Next_ancestors, Node@1) end
                )
            end,
            This = generate_type(Ancestors, Node),
            glam@doc:concat(gleam@list:prepend(Sub_types, This))
    end.