glint

-module(glint).
-compile(no_auto_import).

-export([new/0, add_command/4, execute/2, run/2]).
-export_type([command_input/0, command/0]).

-type command_input() :: {command_input,
                          list(binary()),
                          gleam@map:map_(binary(), glint@flag:flag_value())}.

-opaque command() :: {command,
                      gleam@option:option(fun((command_input()) -> nil)),
                      gleam@map:map_(binary(), command()),
                      gleam@map:map_(binary(), glint@flag:flag_value())}.

-spec new() -> command().
new() ->
    {command, none, gleam@map:new(), gleam@map:new()}.

-spec add_command(
    command(),
    list(binary()),
    fun((command_input()) -> nil),
    list(glint@flag:flag())
) -> command().
add_command(Root, Path, F, Flags) ->
    case Path of
        [] ->
            erlang:setelement(
                4,
                erlang:setelement(2, Root, {some, F}),
                glint@flag:build_map(Flags)
            );

        [X | Xs] ->
            Update_subcommand = fun(Node) ->
                _pipe = Node,
                _pipe@1 = gleam@option:lazy_unwrap(_pipe, fun new/0),
                add_command(_pipe@1, Xs, F, Flags)
            end,
            erlang:setelement(
                3,
                Root,
                gleam@map:update(erlang:element(3, Root), X, Update_subcommand)
            )
    end.

-spec execute_root(command(), list(binary()), list(binary())) -> {ok, nil} |
    {error, snag:snag()}.
execute_root(Cmd, Args, Flags) ->
    case erlang:element(2, Cmd) of
        {some, F} ->
            case begin
                _pipe = gleam@list:try_fold(
                    Flags,
                    erlang:element(4, Cmd),
                    fun glint@flag:update_flags/2
                ),
                snag:context(_pipe, <<"failed to run command"/utf8>>)
            end of
                {error, _try} -> {error, _try};
                {ok, New_flags} ->
                    {ok, F({command_input, Args, New_flags})}
            end;

        none ->
            {error,
             begin
                 _pipe@1 = snag:new(<<"command not found"/utf8>>),
                 snag:layer(_pipe@1, <<"failed to run command"/utf8>>)
             end}
    end.

-spec execute(command(), list(binary())) -> {ok, nil} | {error, snag:snag()}.
execute(Cmd, Args) ->
    {Flags, Args@1} = gleam@list:partition(
        Args,
        fun(_capture) -> gleam@string:starts_with(_capture, <<"--"/utf8>>) end
    ),
    do_execute(Cmd, Args@1, Flags).

-spec do_execute(command(), list(binary()), list(binary())) -> {ok, nil} |
    {error, snag:snag()}.
do_execute(Cmd, Args, Flags) ->
    case Args of
        [] ->
            execute_root(Cmd, [], Flags);

        [Arg | Rest] ->
            case gleam@map:get(erlang:element(3, Cmd), Arg) of
                {ok, Cmd@1} ->
                    do_execute(Cmd@1, Rest, Flags);

                {error, _@1} ->
                    execute_root(Cmd, Args, Flags)
            end
    end.

-spec run(command(), list(binary())) -> nil.
run(Cmd, Args) ->
    case execute(Cmd, Args) of
        {ok, nil} ->
            nil;

        {error, Err} ->
            _pipe = Err,
            _pipe@1 = snag:pretty_print(_pipe),
            gleam@io:println(_pipe@1)
    end.