gleamgen

-module(gleamgen@parameter).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/parameter.gleam").
-export([new/2, with_label/2, name/1, type_/1, has_label/1, render/3, render_parameters/3, to_dynamic/1]).
-export_type([parameter/1]).

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

-opaque parameter(NIG) :: {parameter,
        binary(),
        gleamgen@types:generated_type(NIG),
        gleam@option:option(binary())}.

-file("src/gleamgen/parameter.gleam", 17).
-spec new(binary(), gleamgen@types:generated_type(NIH)) -> parameter(NIH).
new(Name, Type_) ->
    {parameter, Name, Type_, none}.

-file("src/gleamgen/parameter.gleam", 21).
-spec with_label(parameter(NIK), binary()) -> parameter(NIK).
with_label(Parameter, Label) ->
    {parameter,
        erlang:element(2, Parameter),
        erlang:element(3, Parameter),
        {some, Label}}.

-file("src/gleamgen/parameter.gleam", 25).
-spec name(parameter(any())) -> binary().
name(Parameter) ->
    erlang:element(2, Parameter).

-file("src/gleamgen/parameter.gleam", 29).
-spec type_(parameter(NIP)) -> gleamgen@types:generated_type(NIP).
type_(Parameter) ->
    erlang:element(3, Parameter).

-file("src/gleamgen/parameter.gleam", 33).
-spec has_label(parameter(any())) -> boolean().
has_label(Parameter) ->
    gleam@option:is_some(erlang:element(4, Parameter)).

-file("src/gleamgen/parameter.gleam", 38).
?DOC(false).
-spec render(parameter(any()), boolean(), gleamgen@internal@render:context()) -> glam@doc:document().
render(Parameter, Include_labels, Context) ->
    Label@1 = case erlang:element(4, Parameter) of
        {some, Label} when Include_labels ->
            glam@doc:concat(
                [glam@doc:from_string(Label),
                    glam@doc:from_string(<<" "/utf8>>)]
            );

        _ ->
            {concat, []}
    end,
    Name = glam@doc:from_string(erlang:element(2, Parameter)),
    Addition = case gleamgen@types:render_type(erlang:element(3, Parameter)) of
        {ok, Rendered} when erlang:element(2, erlang:element(2, Context)) ->
            glam@doc:concat(
                [glam@doc:from_string(<<":"/utf8>>),
                    glam@doc:from_string(<<" "/utf8>>),
                    erlang:element(2, Rendered)]
            );

        _ ->
            {concat, []}
    end,
    glam@doc:concat([Label@1, Name, Addition]).

-file("src/gleamgen/parameter.gleam", 76).
-spec parameter_type_details(parameter(gleamgen@types:dynamic_())) -> gleamgen@internal@render:rendered_details().
parameter_type_details(Param) ->
    _pipe = gleamgen@types:render_type(type_(Param)),
    _pipe@1 = gleam@result:map(_pipe, fun(R) -> erlang:element(3, R) end),
    gleam@result:unwrap(_pipe@1, {rendered_details, [], {report, [], []}}).

-file("src/gleamgen/parameter.gleam", 84).
-spec do_render_parameters(
    list(parameter(gleamgen@types:dynamic_())),
    list(glam@doc:document()),
    boolean(),
    list(binary()),
    gleamgen@internal@render:rendered_details(),
    boolean(),
    gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
do_render_parameters(
    Parameters,
    Acc,
    Last_parameter_had_label,
    Should_have_been_labeled_params,
    Type_details_acc,
    Include_labels,
    Context
) ->
    case Parameters of
        [] ->
            Doc = gleamgen@internal@render:pretty_list(lists:reverse(Acc)),
            Label_details = case Should_have_been_labeled_params of
                [] ->
                    {rendered_details, [], {report, [], []}};

                Not_labeled when erlang:element(4, erlang:element(2, Context)) ->
                    _record = {rendered_details, [], {report, [], []}},
                    {rendered_details,
                        erlang:element(2, _record),
                        {report,
                            [],
                            [{automatically_added_missing_labels,
                                    lists:reverse(Not_labeled)}]}};

                Not_labeled@1 ->
                    _record@1 = {rendered_details, [], {report, [], []}},
                    {rendered_details,
                        erlang:element(2, _record@1),
                        {report,
                            [{missing_labels, lists:reverse(Not_labeled@1)}],
                            []}}
            end,
            Details = gleamgen@internal@render:merge_details(
                Type_details_acc,
                Label_details
            ),
            {render, Doc, Details};

        [Param | Rest] ->
            Has_label = gleam@option:is_some(erlang:element(4, Param)),
            Next_type_details = gleamgen@internal@render:merge_details(
                Type_details_acc,
                parameter_type_details(Param)
            ),
            case Has_label of
                true ->
                    do_render_parameters(
                        Rest,
                        [render(Param, Include_labels, Context) | Acc],
                        true,
                        Should_have_been_labeled_params,
                        Next_type_details,
                        Include_labels,
                        Context
                    );

                false when Last_parameter_had_label ->
                    Fixed_parameter = case erlang:element(
                        4,
                        erlang:element(2, Context)
                    ) of
                        true ->
                            with_label(Param, erlang:element(2, Param));

                        false ->
                            Param
                    end,
                    Merged_details = gleamgen@internal@render:merge_details(
                        Type_details_acc,
                        parameter_type_details(Fixed_parameter)
                    ),
                    do_render_parameters(
                        Rest,
                        [render(Fixed_parameter, Include_labels, Context) | Acc],
                        true,
                        [erlang:element(2, Param) |
                            Should_have_been_labeled_params],
                        Merged_details,
                        Include_labels,
                        Context
                    );

                false ->
                    do_render_parameters(
                        Rest,
                        [render(Param, Include_labels, Context) | Acc],
                        Last_parameter_had_label,
                        Should_have_been_labeled_params,
                        Next_type_details,
                        Include_labels,
                        Context
                    )
            end
    end.

-file("src/gleamgen/parameter.gleam", 60).
?DOC(false).
-spec render_parameters(
    list(parameter(gleamgen@types:dynamic_())),
    boolean(),
    gleamgen@internal@render:context()
) -> gleamgen@internal@render:rendered().
render_parameters(Parameters, Include_labels, Context) ->
    do_render_parameters(
        Parameters,
        [],
        false,
        [],
        {rendered_details, [], {report, [], []}},
        Include_labels,
        Context
    ).

-file("src/gleamgen/parameter.gleam", 176).
-spec to_dynamic(parameter(any())) -> parameter(gleamgen@types:dynamic_()).
to_dynamic(_parameter) ->
    gleamgen_ffi:identity(_parameter).