roundabout

-module(roundabout@generate_segments_to_route).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/roundabout/generate_segments_to_route.gleam").
-export([generate_segments_to_route/2, generate_segments_to_route_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_segments_to_route.gleam", 97).
-spec generate_segments_to_route_case(
    list(roundabout@node:info()),
    roundabout@node:node_()
) -> glam@doc:document().
generate_segments_to_route_case(Ancestors, Node) ->
    Matched_params = begin
        _pipe = erlang:element(3, erlang:element(2, Node)),
        _pipe@1 = gleam@list:map(_pipe, fun(Segment) -> case Segment of
                    {seg_lit, Value} ->
                        glam@doc:from_string(
                            <<<<"\""/utf8,
                                    (roundabout@constant:value(Value))/binary>>/binary,
                                "\""/utf8>>
                        );

                    {seg_param, Param} ->
                        glam@doc:from_string(roundabout@parameter:name(Param))
                end end),
        _pipe@2 = (fun(Self) ->
            case gleam@list:is_empty(erlang:element(3, Node)) of
                true ->
                    Self;

                false ->
                    lists:append(
                        Self,
                        [glam@doc:from_string(<<"..rest"/utf8>>)]
                    )
            end
        end)(_pipe@1),
        glam@doc:join(_pipe@2, glam@doc:from_string(<<", "/utf8>>))
    end,
    Left = glam@doc:concat(
        [glam@doc:from_string(<<"["/utf8>>),
            Matched_params,
            glam@doc:from_string(<<"]"/utf8>>)]
    ),
    Match_right_inner = begin
        _pipe@3 = erlang:element(3, erlang:element(2, Node)),
        _pipe@4 = gleam@list:filter_map(_pipe@3, fun(Seg) -> case Seg of
                    {seg_lit, _} ->
                        {error, nil};

                    {seg_param, Param@1} ->
                        {ok, roundabout@parameter:name(Param@1)}
                end end),
        _pipe@5 = (fun(Params) ->
            case gleam@list:is_empty(erlang:element(3, Node)) of
                true ->
                    Params;

                false ->
                    lists:append(Params, [<<"sub"/utf8>>])
            end
        end)(_pipe@4),
        gleam@string:join(_pipe@5, <<", "/utf8>>)
    end,
    Match_right_inner@2 = case Match_right_inner of
        <<""/utf8>> ->
            <<""/utf8>>;

        Match_right_inner@1 ->
            <<<<"("/utf8, Match_right_inner@1/binary>>/binary, ")"/utf8>>
    end,
    Right = case gleam@list:is_empty(erlang:element(3, Node)) of
        true ->
            _pipe@6 = glam@doc:from_string(
                <<(roundabout@common:get_type_name(
                        Ancestors,
                        erlang:element(2, Node)
                    ))/binary,
                    Match_right_inner@2/binary>>
            ),
            _pipe@7 = glam@doc:append(_pipe@6, roundabout@common:pipe_join()),
            glam@doc:append(_pipe@7, glam@doc:from_string(<<"Ok"/utf8>>));

        false ->
            Fn_name = <<(roundabout@common:get_function_name(
                    Ancestors,
                    erlang:element(2, Node)
                ))/binary,
                "_segments_to_route"/utf8>>,
            glam@doc:concat(
                [glam@doc:from_string(<<Fn_name/binary, "(rest)"/utf8>>),
                    roundabout@common:pipe_join(),
                    glam@doc:from_string(<<"result.map(fn(sub) {"/utf8>>),
                    glam@doc:nest_docs(
                        [{line, 1},
                            glam@doc:from_string(
                                <<(roundabout@common:get_type_name(
                                        Ancestors,
                                        erlang:element(2, Node)
                                    ))/binary,
                                    Match_right_inner@2/binary>>
                            )],
                        2
                    ),
                    {line, 1},
                    glam@doc:from_string(<<"})"/utf8>>)]
            )
    end,
    Right@1 = gleam@list:fold(
        erlang:element(3, erlang:element(2, Node)),
        Right,
        fun(Acc, Segment@1) -> case Segment@1 of
                {seg_lit, _} ->
                    Acc;

                {seg_param, Param@2} ->
                    case roundabout@parameter:kind(Param@2) of
                        str ->
                            Acc;

                        int ->
                            Name = roundabout@parameter:name(Param@2),
                            glam@doc:concat(
                                [glam@doc:from_string(
                                        <<<<<<<<"with_int("/utf8, Name/binary>>/binary,
                                                    ", fn("/utf8>>/binary,
                                                Name/binary>>/binary,
                                            ") { "/utf8>>
                                    ),
                                    glam@doc:nest_docs([{line, 1}, Acc], 2),
                                    {line, 1},
                                    glam@doc:from_string(<<" })"/utf8>>)]
                            )
                    end
            end end
    ),
    _pipe@8 = Left,
    _pipe@9 = glam@doc:append(_pipe@8, roundabout@common:case_arrow()),
    _pipe@10 = glam@doc:append(_pipe@9, Right@1),
    glam@doc:nest(_pipe@10, 2).

-file("src/roundabout/generate_segments_to_route.gleam", 44).
?DOC(false).
-spec generate_segments_to_route(
    list(roundabout@node:info()),
    roundabout@node:node_()
) -> glam@doc:document().
generate_segments_to_route(Ancestors, Node) ->
    Next_ancestors = gleam@list:prepend(Ancestors, erlang:element(2, Node)),
    Segments_to_route_cases = begin
        _pipe = erlang:element(3, Node),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(_capture) ->
                generate_segments_to_route_case(Next_ancestors, _capture)
            end
        ),
        _pipe@2 = glam@doc:join(_pipe@1, {line, 1}),
        _pipe@3 = glam@doc:append(_pipe@2, {line, 1}),
        glam@doc:append(
            _pipe@3,
            glam@doc:from_string(<<"_ -> Error(Nil)"/utf8>>)
        )
    end,
    Function_name = begin
        _pipe@4 = [roundabout@common:get_function_name(
                Ancestors,
                erlang:element(2, Node)
            ),
            <<"segments_to_route"/utf8>>],
        _pipe@5 = gleam@list:filter(
            _pipe@4,
            fun(Name) -> not gleam@string:is_empty(Name) end
        ),
        gleam@string:join(_pipe@5, <<"_"/utf8>>)
    end,
    Type_name = roundabout@common:get_type_name(
        Ancestors,
        erlang:element(2, Node)
    ),
    Pub_prefix = case gleam@list:is_empty(Ancestors) of
        true ->
            <<"pub "/utf8>>;

        false ->
            <<""/utf8>>
    end,
    glam@doc:concat(
        [glam@doc:from_string(
                <<<<<<<<<<Pub_prefix/binary, "fn "/utf8>>/binary,
                                Function_name/binary>>/binary,
                            "(segments: List(String)) -> Result("/utf8>>/binary,
                        Type_name/binary>>/binary,
                    "Route, Nil) {"/utf8>>
            ),
            glam@doc:nest_docs(
                [{line, 1},
                    glam@doc:from_string(<<"case segments {"/utf8>>),
                    glam@doc:nest_docs([{line, 1}, Segments_to_route_cases], 2),
                    {line, 1},
                    glam@doc:from_string(<<"}"/utf8>>)],
                2
            ),
            {line, 1},
            glam@doc:from_string(<<"}"/utf8>>),
            glam@doc:lines(2)]
    ).

-file("src/roundabout/generate_segments_to_route.gleam", 22).
?DOC(false).
-spec generate_segments_to_route_rec(
    list(roundabout@node:info()),
    roundabout@node:node_()
) -> glam@doc:document().
generate_segments_to_route_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 = gleam@list:map(
                erlang:element(3, Node),
                fun(Sub) ->
                    generate_segments_to_route_rec(Next_ancestors, Sub)
                end
            ),
            This = generate_segments_to_route(Ancestors, Node),
            glam@doc:concat(gleam@list:prepend(Sub_types, This))
    end.