clip

-module(clip@arg).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([to_arg_info/1, to_arg_info_many/1, to_arg_info_many1/1, try_map/2, map/2, default/2, optional/1, help/2, int/1, float/1, new/1, run/2, run_many/2, run_many1/2]).
-export_type([arg/1]).

-opaque arg(GBW) :: {arg,
        binary(),
        gleam@option:option(GBW),
        gleam@option:option(binary()),
        fun((binary()) -> {ok, GBW} | {error, binary()})}.

-spec pos_info(arg(any())) -> clip@internal@arg_info:positional_info().
pos_info(Arg) ->
    case Arg of
        {arg, Name, Default, Help, _} ->
            {positional_info,
                Name,
                begin
                    _pipe = Default,
                    gleam@option:map(_pipe, fun gleam@string:inspect/1)
                end,
                Help,
                no_repeat}
    end.

-spec to_arg_info(arg(any())) -> clip@internal@arg_info:arg_info().
to_arg_info(Arg) ->
    erlang:setelement(3, clip@internal@arg_info:empty(), [pos_info(Arg)]).

-spec to_arg_info_many(arg(any())) -> clip@internal@arg_info:arg_info().
to_arg_info_many(Arg) ->
    erlang:setelement(
        3,
        clip@internal@arg_info:empty(),
        [erlang:setelement(5, pos_info(Arg), many_repeat)]
    ).

-spec to_arg_info_many1(arg(any())) -> clip@internal@arg_info:arg_info().
to_arg_info_many1(Arg) ->
    erlang:setelement(
        3,
        clip@internal@arg_info:empty(),
        [erlang:setelement(5, pos_info(Arg), many1_repeat)]
    ).

-spec try_map(arg(GCF), fun((GCF) -> {ok, GCH} | {error, binary()})) -> arg(GCH).
try_map(Arg, F) ->
    case Arg of
        {arg, Name, _, Help, Try_map} ->
            {arg,
                Name,
                none,
                Help,
                fun(Arg@1) ->
                    gleam@result:'try'(Try_map(Arg@1), fun(A) -> F(A) end)
                end}
    end.

-spec map(arg(GCL), fun((GCL) -> GCN)) -> arg(GCN).
map(Arg, F) ->
    try_map(Arg, fun(A) -> {ok, F(A)} end).

-spec default(arg(GCU), GCU) -> arg(GCU).
default(Arg, Default) ->
    case Arg of
        {arg, Name, _, Help, Try_map} ->
            {arg, Name, {some, Default}, Help, Try_map}
    end.

-spec optional(arg(GCP)) -> arg({ok, GCP} | {error, nil}).
optional(Arg) ->
    _pipe = Arg,
    _pipe@1 = map(_pipe, fun(Field@0) -> {ok, Field@0} end),
    default(_pipe@1, {error, nil}).

-spec help(arg(GCX), binary()) -> arg(GCX).
help(Arg, Help) ->
    case Arg of
        {arg, Name, Default, _, Try_map} ->
            {arg, Name, Default, {some, Help}, Try_map}
    end.

-spec int(arg(binary())) -> arg(integer()).
int(Arg) ->
    _pipe = Arg,
    try_map(_pipe, fun(Val) -> _pipe@1 = gleam@int:parse(Val),
            gleam@result:map_error(
                _pipe@1,
                fun(_) ->
                    <<"Non-integer value provided for "/utf8,
                        (erlang:element(2, Arg))/binary>>
                end
            ) end).

-spec float(arg(binary())) -> arg(float()).
float(Arg) ->
    _pipe = Arg,
    try_map(_pipe, fun(Val) -> _pipe@1 = gleam@float:parse(Val),
            gleam@result:map_error(
                _pipe@1,
                fun(_) ->
                    <<"Non-float value provided for "/utf8,
                        (erlang:element(2, Arg))/binary>>
                end
            ) end).

-spec new(binary()) -> arg(binary()).
new(Name) ->
    {arg, Name, none, none, fun(Field@0) -> {ok, Field@0} end}.

-spec run(arg(GDF), list(binary())) -> {ok, {GDF, list(binary())}} |
    {error, binary()}.
run(Arg, Args) ->
    case {Args, erlang:element(3, Arg)} of
        {[Head | Rest], _} ->
            case gleam@string:starts_with(<<"head"/utf8>>, <<"-"/utf8>>) of
                true ->
                    _pipe = run(Arg, Rest),
                    gleam@result:map(
                        _pipe,
                        fun(V) ->
                            {erlang:element(1, V),
                                [Head | erlang:element(2, V)]}
                        end
                    );

                false ->
                    gleam@result:'try'(
                        (erlang:element(5, Arg))(Head),
                        fun(A) -> {ok, {A, Rest}} end
                    )
            end;

        {[], {some, V@1}} ->
            {ok, {V@1, []}};

        {[], none} ->
            {error,
                <<"missing required arg: "/utf8,
                    (erlang:element(2, Arg))/binary>>}
    end.

-spec run_many_aux(list(GDI), arg(GDI), list(binary())) -> {ok,
        {list(GDI), list(binary())}} |
    {error, binary()}.
run_many_aux(Acc, Arg, Args) ->
    case Args of
        [] ->
            {ok, {lists:reverse(Acc), []}};

        _ ->
            case run(Arg, Args) of
                {ok, {A, Rest}} ->
                    run_many_aux([A | Acc], Arg, Rest);

                {error, _} ->
                    {ok, {lists:reverse(Acc), Args}}
            end
    end.

-spec run_many(arg(GDN), list(binary())) -> {ok, {list(GDN), list(binary())}} |
    {error, binary()}.
run_many(Arg, Args) ->
    run_many_aux([], Arg, Args).

-spec run_many1(arg(GDR), list(binary())) -> {ok, {list(GDR), list(binary())}} |
    {error, binary()}.
run_many1(Arg, Args) ->
    gleam@result:'try'(
        run_many_aux([], Arg, Args),
        fun(_use0) ->
            {Vs, Rest} = _use0,
            case Vs of
                [] ->
                    {error,
                        <<"must provide at least one valid value for: "/utf8,
                            (erlang:element(2, Arg))/binary>>};

                _ ->
                    {ok, {Vs, Rest}}
            end
        end
    ).