clip

-module(clip@arg_info).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/clip/arg_info.gleam").
-export([empty/0, merge/2, help_text/3]).
-export_type([repeat/0, named_info/0, positional_info/0, flag_info/0, arg_info/0]).

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

-type repeat() :: no_repeat | many_repeat | many1_repeat.

-type named_info() :: {named_info,
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(binary())}.

-type positional_info() :: {positional_info,
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        repeat()}.

-type flag_info() :: {flag_info,
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(binary())}.

-type arg_info() :: {arg_info,
        list(named_info()),
        list(positional_info()),
        list(flag_info()),
        list(binary())}.

-file("src/clip/arg_info.gleam", 44).
?DOC(" Create an empty `ArgInfo` value.\n").
-spec empty() -> arg_info().
empty() ->
    {arg_info, [], [], [], []}.

-file("src/clip/arg_info.gleam", 49).
?DOC(" Merge two `ArgInfo` values.\n").
-spec merge(arg_info(), arg_info()) -> arg_info().
merge(A, B) ->
    {arg_info,
        lists:append(erlang:element(2, A), erlang:element(2, B)),
        lists:append(erlang:element(3, A), erlang:element(3, B)),
        lists:append(erlang:element(4, A), erlang:element(4, B)),
        lists:append(erlang:element(5, A), erlang:element(5, B))}.

-file("src/clip/arg_info.gleam", 58).
-spec named_str(named_info()) -> binary().
named_str(N_info) ->
    Long_name = <<"--"/utf8, (erlang:element(2, N_info))/binary>>,
    Short_name = gleam@option:map(
        erlang:element(3, N_info),
        fun(S) -> <<"-"/utf8, S/binary>> end
    ),
    Names = begin
        _pipe = Short_name,
        _pipe@1 = gleam@option:map(_pipe, fun(S@1) -> [S@1] end),
        gleam@option:unwrap(_pipe@1, [])
    end,
    Names_list = [Long_name | Names],
    {Start, End} = case erlang:element(4, N_info) of
        {some, _} ->
            {<<"["/utf8>>, <<"]"/utf8>>};

        none ->
            {<<"("/utf8>>, <<")"/utf8>>}
    end,
    <<<<<<<<Start/binary,
                    ((gleam@string:join(Names_list, <<","/utf8>>)))/binary>>/binary,
                " "/utf8>>/binary,
            (string:uppercase(erlang:element(2, N_info)))/binary>>/binary,
        End/binary>>.

-file("src/clip/arg_info.gleam", 74).
-spec flag_str(flag_info()) -> binary().
flag_str(F_info) ->
    Long_name = <<"--"/utf8, (erlang:element(2, F_info))/binary>>,
    Short_name = gleam@option:map(
        erlang:element(3, F_info),
        fun(S) -> <<"-"/utf8, S/binary>> end
    ),
    Names = begin
        _pipe = Short_name,
        _pipe@1 = gleam@option:map(_pipe, fun(S@1) -> [S@1] end),
        gleam@option:unwrap(_pipe@1, [])
    end,
    Names_list = [Long_name | Names],
    <<<<"["/utf8, ((gleam@string:join(Names_list, <<","/utf8>>)))/binary>>/binary,
        "]"/utf8>>.

-file("src/clip/arg_info.gleam", 82).
-spec pos_str(positional_info()) -> binary().
pos_str(P_info) ->
    Name = string:uppercase(erlang:element(2, P_info)),
    Name@1 = case erlang:element(5, P_info) of
        no_repeat ->
            Name;

        many_repeat ->
            <<<<"["/utf8, Name/binary>>/binary, "...]"/utf8>>;

        many1_repeat ->
            <<Name/binary, "..."/utf8>>
    end,
    Name@1.

-file("src/clip/arg_info.gleam", 93).
?DOC(" Generate user-facing help text from `ArgInfo`, a name, and a description.\n").
-spec help_text(arg_info(), binary(), binary()) -> binary().
help_text(Info, Name, Description) ->
    Sub_usage = case erlang:element(5, Info) of
        [] ->
            [];

        _ ->
            [<<"<COMMAND>"/utf8>>]
    end,
    Opt_usage = case {erlang:element(2, Info), erlang:element(4, Info)} of
        {[], []} ->
            [];

        {_, _} ->
            [<<"[OPTIONS]"/utf8>>]
    end,
    Named_args = begin
        _pipe = erlang:element(2, Info),
        gleam@list:map(_pipe, fun named_str/1)
    end,
    Flag_args = begin
        _pipe@1 = erlang:element(4, Info),
        gleam@list:map(_pipe@1, fun flag_str/1)
    end,
    Pos_args = begin
        _pipe@2 = erlang:element(3, Info),
        gleam@list:map(_pipe@2, fun pos_str/1)
    end,
    Max_size = begin
        _pipe@3 = Named_args,
        _pipe@4 = lists:append(_pipe@3, Flag_args),
        _pipe@5 = lists:append(_pipe@4, Pos_args),
        _pipe@6 = gleam@list:map(_pipe@5, fun string:length/1),
        gleam@list:fold(_pipe@6, 0, fun gleam@int:max/2)
    end,
    Usage = gleam@string:join(
        begin
            _pipe@7 = [Name],
            _pipe@8 = lists:append(_pipe@7, Sub_usage),
            _pipe@9 = lists:append(_pipe@8, Opt_usage),
            lists:append(_pipe@9, Pos_args)
        end,
        <<" "/utf8>>
    ),
    Sub_desc = begin
        _pipe@10 = erlang:element(5, Info),
        _pipe@11 = gleam@list:map(
            _pipe@10,
            fun(Sub) -> <<"  "/utf8, Sub/binary>> end
        ),
        gleam@string:join(_pipe@11, <<"\n"/utf8>>)
    end,
    Pos_desc = begin
        _pipe@12 = erlang:element(3, Info),
        _pipe@22 = gleam@list:map(
            _pipe@12,
            fun(P_info) ->
                Name@1 = begin
                    _pipe@13 = P_info,
                    _pipe@14 = pos_str(_pipe@13),
                    gleam@string:pad_end(_pipe@14, Max_size, <<" "/utf8>>)
                end,
                Help_text = case {erlang:element(5, P_info),
                    erlang:element(3, P_info)} of
                    {many_repeat, _} ->
                        _pipe@15 = erlang:element(4, P_info),
                        _pipe@16 = gleam@option:map(
                            _pipe@15,
                            fun(H) -> <<H/binary, " (zero or more)"/utf8>> end
                        ),
                        gleam@option:unwrap(_pipe@16, <<"Zero or more"/utf8>>);

                    {many1_repeat, _} ->
                        _pipe@17 = erlang:element(4, P_info),
                        _pipe@18 = gleam@option:map(
                            _pipe@17,
                            fun(H@1) ->
                                <<H@1/binary, " (one or more)"/utf8>>
                            end
                        ),
                        gleam@option:unwrap(_pipe@18, <<"One or more"/utf8>>);

                    {no_repeat, none} ->
                        _pipe@19 = erlang:element(4, P_info),
                        gleam@option:unwrap(_pipe@19, <<""/utf8>>);

                    {no_repeat, {some, V}} ->
                        _pipe@20 = erlang:element(4, P_info),
                        _pipe@21 = gleam@option:map(
                            _pipe@20,
                            fun(H@2) ->
                                <<<<<<H@2/binary, " (default: "/utf8>>/binary,
                                        V/binary>>/binary,
                                    ")"/utf8>>
                            end
                        ),
                        gleam@option:unwrap(
                            _pipe@21,
                            <<"Default: "/utf8, V/binary>>
                        )
                end,
                <<<<Name@1/binary, "\t"/utf8>>/binary, Help_text/binary>>
            end
        ),
        _pipe@23 = gleam@list:map(
            _pipe@22,
            fun(L) -> <<"  "/utf8, L/binary>> end
        ),
        gleam@string:join(_pipe@23, <<"\n"/utf8>>)
    end,
    Named_desc = begin
        _pipe@24 = erlang:element(2, Info),
        _pipe@30 = gleam@list:map(
            _pipe@24,
            fun(N_info) ->
                Names = begin
                    _pipe@25 = N_info,
                    _pipe@26 = named_str(_pipe@25),
                    gleam@string:pad_end(_pipe@26, Max_size, <<" "/utf8>>)
                end,
                case erlang:element(4, N_info) of
                    none ->
                        <<<<Names/binary, "\t"/utf8>>/binary,
                            (begin
                                _pipe@27 = erlang:element(5, N_info),
                                gleam@option:unwrap(_pipe@27, <<""/utf8>>)
                            end)/binary>>;

                    {some, V@1} ->
                        <<<<Names/binary, "\t"/utf8>>/binary,
                            (begin
                                _pipe@28 = erlang:element(5, N_info),
                                _pipe@29 = gleam@option:map(
                                    _pipe@28,
                                    fun(H@3) ->
                                        <<<<<<H@3/binary, " (default: "/utf8>>/binary,
                                                V@1/binary>>/binary,
                                            ")"/utf8>>
                                    end
                                ),
                                gleam@option:unwrap(
                                    _pipe@29,
                                    <<"Default: "/utf8, V@1/binary>>
                                )
                            end)/binary>>
                end
            end
        ),
        _pipe@31 = gleam@list:map(
            _pipe@30,
            fun(L@1) -> <<"  "/utf8, L@1/binary>> end
        ),
        gleam@string:join(_pipe@31, <<"\n"/utf8>>)
    end,
    Flag_desc = begin
        _pipe@32 = erlang:element(4, Info),
        _pipe@36 = gleam@list:map(
            _pipe@32,
            fun(F_info) ->
                <<<<(begin
                            _pipe@33 = F_info,
                            _pipe@34 = flag_str(_pipe@33),
                            gleam@string:pad_end(
                                _pipe@34,
                                Max_size,
                                <<" "/utf8>>
                            )
                        end)/binary,
                        "\t"/utf8>>/binary,
                    (begin
                        _pipe@35 = erlang:element(4, F_info),
                        gleam@option:unwrap(_pipe@35, <<""/utf8>>)
                    end)/binary>>
            end
        ),
        _pipe@37 = gleam@list:map(
            _pipe@36,
            fun(L@2) -> <<"  "/utf8, L@2/binary>> end
        ),
        gleam@string:join(_pipe@37, <<"\n"/utf8>>)
    end,
    Opt_desc = begin
        _pipe@38 = [Named_desc, Flag_desc],
        _pipe@39 = gleam@list:filter(
            _pipe@38,
            fun(Desc) -> Desc /= <<""/utf8>> end
        ),
        gleam@string:join(_pipe@39, <<"\n"/utf8>>)
    end,
    Sub_lines = case gleam@string:is_empty(Sub_desc) of
        true ->
            [];

        false ->
            [<<"Commands:"/utf8>>, Sub_desc]
    end,
    Pos_lines = case gleam@string:is_empty(Pos_desc) of
        true ->
            [];

        false ->
            [<<"Arguments:"/utf8>>, Pos_desc]
    end,
    Opt_lines = case gleam@string:is_empty(Opt_desc) of
        true ->
            [];

        false ->
            [<<"Options:"/utf8>>, Opt_desc]
    end,
    _pipe@40 = [Name,
        <<"  "/utf8, Description/binary>>,
        <<"Usage:"/utf8>>,
        <<"  "/utf8, Usage/binary>>],
    _pipe@41 = lists:append(_pipe@40, Sub_lines),
    _pipe@42 = lists:append(_pipe@41, Pos_lines),
    _pipe@43 = lists:append(_pipe@42, Opt_lines),
    gleam@string:join(_pipe@43, <<"\n\n"/utf8>>).