-module(caffeine_lang@cli@handler).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/cli/handler.gleam").
-export([handle_args/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.

-file("src/caffeine_lang/cli/handler.gleam", 138).
-spec log(caffeine_lang@core@logger:log_level(), binary()) -> nil.
log(Log_level, Message) ->
    case Log_level of
        verbose ->
            gleam_stdlib:println(Message);

        minimal ->
            nil
    end.

-file("src/caffeine_lang/cli/handler.gleam", 109).
-spec print_usage(caffeine_lang@core@logger:log_level()) -> nil.
print_usage(Log_level) ->
    log(Log_level, <<"caffeine "/utf8, (<<"2.0.3"/utf8>>)/binary>>),
    log(
        Log_level,
        <<"A compiler for generating reliability artifacts from service expectation definitions."/utf8>>
    ),
    log(Log_level, <<""/utf8>>),
    log(Log_level, <<"USAGE:"/utf8>>),
    log(
        Log_level,
        <<"    caffeine compile [--quiet] <blueprint_file> <expectations_directory> [output_file]"/utf8>>
    ),
    log(Log_level, <<""/utf8>>),
    log(Log_level, <<"ARGUMENTS:"/utf8>>),
    log(
        Log_level,
        <<"    [output_file]    Output file path or directory (prints to stdout if omitted)"/utf8>>
    ),
    log(Log_level, <<""/utf8>>),
    log(Log_level, <<"OPTIONS:"/utf8>>),
    log(
        Log_level,
        <<"    --quiet          Suppress compilation progress output"/utf8>>
    ),
    log(Log_level, <<"    -h, --help       Print help information"/utf8>>),
    log(Log_level, <<"    -V, --version    Print version information"/utf8>>).

-file("src/caffeine_lang/cli/handler.gleam", 134).
-spec print_version(caffeine_lang@core@logger:log_level()) -> nil.
print_version(Log_level) ->
    log(Log_level, <<"caffeine "/utf8, (<<"2.0.3"/utf8>>)/binary>>).

-file("src/caffeine_lang/cli/handler.gleam", 145).
-spec result_to_exit_status(
    {ok, nil} | {error, binary()},
    caffeine_lang@core@logger:log_level()
) -> caffeine_lang@cli@exit_status_codes:exit_status_codes().
result_to_exit_status(Res, Log_level) ->
    case Res of
        {ok, _} ->
            success;

        {error, Msg} ->
            log(Log_level, Msg),
            failure
    end.

-file("src/caffeine_lang/cli/handler.gleam", 73).
-spec compile(
    binary(),
    binary(),
    gleam@option:option(binary()),
    caffeine_lang@core@logger:log_level()
) -> caffeine_lang@cli@exit_status_codes:exit_status_codes().
compile(Blueprint_file, Expectations_dir, Output_path, Log_level) ->
    Config = {compilation_config, Log_level},
    _pipe@3 = begin
        gleam@result:'try'(
            begin
                _pipe = caffeine_lang@core@compiler:compile(
                    Blueprint_file,
                    Expectations_dir,
                    Config
                ),
                gleam@result:map_error(
                    _pipe,
                    fun(Err) ->
                        <<"Compilation error: "/utf8,
                            (erlang:element(2, Err))/binary>>
                    end
                )
            end,
            fun(Output) -> case Output_path of
                    none ->
                        log(Log_level, Output),
                        {ok, nil};

                    {some, Path} ->
                        Output_file = case simplifile_erl:is_directory(Path) of
                            {ok, true} ->
                                <<Path/binary, "/main.tf"/utf8>>;

                            _ ->
                                Path
                        end,
                        _pipe@1 = simplifile:write(Output_file, Output),
                        _pipe@2 = gleam@result:map(
                            _pipe@1,
                            fun(_) ->
                                log(
                                    Log_level,
                                    <<"Successfully compiled to "/utf8,
                                        Output_file/binary>>
                                )
                            end
                        ),
                        gleam@result:map_error(
                            _pipe@2,
                            fun(Err@1) ->
                                <<"Error writing output file: "/utf8,
                                    (gleam@string:inspect(Err@1))/binary>>
                            end
                        )
                end end
        )
    end,
    result_to_exit_status(_pipe@3, Log_level).

-file("src/caffeine_lang/cli/handler.gleam", 14).
?DOC(false).
-spec handle_args(list(binary())) -> caffeine_lang@cli@exit_status_codes:exit_status_codes().
handle_args(Args) ->
    case Args of
        [<<"compile"/utf8>>,
            <<"--quiet"/utf8>>,
            Blueprint_file,
            Expectations_dir,
            Output_file] ->
            compile(
                Blueprint_file,
                Expectations_dir,
                {some, Output_file},
                minimal
            );

        [<<"compile"/utf8>>,
            <<"--quiet"/utf8>>,
            Blueprint_file@1,
            Expectations_dir@1] ->
            compile(Blueprint_file@1, Expectations_dir@1, none, minimal);

        [<<"compile"/utf8>>,
            Blueprint_file@2,
            Expectations_dir@2,
            Output_file@1] ->
            compile(
                Blueprint_file@2,
                Expectations_dir@2,
                {some, Output_file@1},
                verbose
            );

        [<<"compile"/utf8>>, Blueprint_file@3, Expectations_dir@3] ->
            compile(Blueprint_file@3, Expectations_dir@3, none, verbose);

        [<<"--help"/utf8>>] ->
            print_usage(verbose),
            success;

        [<<"-h"/utf8>>] ->
            print_usage(verbose),
            success;

        [<<"--version"/utf8>>] ->
            print_version(verbose),
            success;

        [<<"-V"/utf8>>] ->
            print_version(verbose),
            success;

        [<<"--quiet"/utf8>>, <<"--help"/utf8>>] ->
            print_usage(minimal),
            success;

        [<<"--quiet"/utf8>>, <<"-h"/utf8>>] ->
            print_usage(minimal),
            success;

        [<<"--help"/utf8>>, <<"--quiet"/utf8>>] ->
            print_usage(minimal),
            success;

        [<<"-h"/utf8>>, <<"--quiet"/utf8>>] ->
            print_usage(minimal),
            success;

        [<<"--quiet"/utf8>>, <<"--version"/utf8>>] ->
            print_version(minimal),
            success;

        [<<"--quiet"/utf8>>, <<"-V"/utf8>>] ->
            print_version(minimal),
            success;

        [<<"--version"/utf8>>, <<"--quiet"/utf8>>] ->
            print_version(minimal),
            success;

        [<<"-V"/utf8>>, <<"--quiet"/utf8>>] ->
            print_version(minimal),
            success;

        [<<"--quiet"/utf8>>] ->
            print_usage(minimal),
            success;

        [] ->
            print_usage(verbose),
            success;

        _ ->
            log(verbose, <<"Error: Invalid arguments"/utf8>>),
            log(verbose, <<""/utf8>>),
            print_usage(verbose),
            failure
    end.