cactus

-module(cactus@run).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([get_actions/2, as_string/1, parse_action/1, run/2]).
-export_type([action_kind/0, action/0]).

-type action_kind() :: module | sub_command | binary.

-type action() :: {action, binary(), action_kind(), list(binary())}.

-spec get_actions(binary(), binary()) -> {ok, list(tom:toml())} |
    {error, cactus@errors:cactus_err()}.
get_actions(Path, Action) ->
    gleam@result:'try'(
        cactus@util:parse_gleam_toml(Path),
        fun(Manifest) ->
            gleam@result:'try'(
                cactus@errors:as_invalid_field_err(
                    tom:get_table(Manifest, [<<"cactus"/utf8>>, Action])
                ),
                fun(Action_body) ->
                    cactus@errors:as_invalid_field_err(
                        tom:get_array(Action_body, [<<"actions"/utf8>>])
                    )
                end
            )
        end
    ).

-spec as_string(tom:toml()) -> binary().
as_string(T) ->
    case T of
        {string, X} ->
            X;

        _ ->
            gleam@io:println_error(<<"Invalid toml field"/utf8>>),
            shellout_ffi:os_exit(1),
            erlang:error(#{gleam_error => panic,
                    message => <<"unreachable"/utf8>>,
                    module => <<"cactus/run"/utf8>>,
                    function => <<"as_string"/utf8>>,
                    line => 95})
    end.

-spec parse_action(tom:toml()) -> {ok, action()} |
    {error, cactus@errors:cactus_err()}.
parse_action(Raw) ->
    case Raw of
        {inline_table, T} ->
            gleam@result:'try'(
                cactus@errors:as_invalid_field_err(
                    tom:get_string(T, [<<"command"/utf8>>])
                ),
                fun(Command) ->
                    Kind = begin
                        _pipe = tom:get_string(T, [<<"kind"/utf8>>]),
                        _pipe@1 = gleam@result:map(
                            _pipe,
                            fun gleam@string:lowercase/1
                        ),
                        gleam@result:unwrap(_pipe@1, <<"module"/utf8>>)
                    end,
                    Args = begin
                        _pipe@2 = tom:get_array(T, [<<"args"/utf8>>]),
                        _pipe@3 = gleam@result:unwrap(_pipe@2, []),
                        gleam@list:map(_pipe@3, fun as_string/1)
                    end,
                    Action_kind = case Kind of
                        <<"module"/utf8>> ->
                            module;

                        <<"sub_command"/utf8>> ->
                            sub_command;

                        <<"binary"/utf8>> ->
                            binary;

                        _ ->
                            module
                    end,
                    {ok, {action, Command, Action_kind, Args}}
                end
            );

        _ ->
            {error, invalid_toml_err}
    end.

-spec run(binary(), binary()) -> {ok, list(binary())} |
    {error, cactus@errors:cactus_err()}.
run(Path, Action) ->
    gleam@result:'try'(
        get_actions(Path, Action),
        fun(Actions) -> _pipe = Actions,
            _pipe@1 = gleam@list:map(_pipe, fun parse_action/1),
            _pipe@2 = gleam@list:map(
                _pipe@1,
                fun(Parse_result) ->
                    gleam@result:'try'(
                        Parse_result,
                        fun(Action@1) ->
                            {Bin, Args} = case erlang:element(3, Action@1) of
                                module ->
                                    {<<"gleam"/utf8>>,
                                        lists:append(
                                            [<<"run"/utf8>>,
                                                <<"-m"/utf8>>,
                                                erlang:element(2, Action@1),
                                                <<"--"/utf8>>],
                                            erlang:element(4, Action@1)
                                        )};

                                sub_command ->
                                    {<<"gleam"/utf8>>,
                                        lists:append(
                                            [erlang:element(2, Action@1)],
                                            erlang:element(4, Action@1)
                                        )};

                                binary ->
                                    {erlang:element(2, Action@1),
                                        erlang:element(4, Action@1)}
                            end,
                            gleam@io:println(
                                <<<<<<"Running: "/utf8, Bin/binary>>/binary,
                                        " "/utf8>>/binary,
                                    (gleam@string:join(Args, <<" "/utf8>>))/binary>>
                            ),
                            case shellout:command(Bin, Args, <<"."/utf8>>, []) of
                                {ok, Res} ->
                                    gleam@io:print(Res),
                                    {ok, Res};

                                {error, {_, Err}} ->
                                    {error, {action_failed_err, Err}}
                            end
                        end
                    )
                end
            ),
            gleam@result:all(_pipe@2) end
    ).