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

-file("src/oaspec/cli.gleam", 207).
?DOC(" Pure config loading and validation pipeline.\n").
-spec load_config(
    binary(),
    gleam@option:option(binary()),
    gleam@option:option(binary())
) -> {ok, oaspec@config:config()} | {error, binary()}.
load_config(Config_path, Mode_opt, Output_opt) ->
    gleam@result:'try'(
        begin
            _pipe = oaspec@config:load(Config_path),
            gleam@result:map_error(_pipe, fun oaspec@config:error_to_string/1)
        end,
        fun(Cfg) -> gleam@result:'try'(case Mode_opt of
                    none ->
                        {ok, Cfg};

                    {some, Mode_str} ->
                        _pipe@1 = oaspec@config:parse_mode(Mode_str),
                        _pipe@2 = gleam@result:map(
                            _pipe@1,
                            fun(M) -> oaspec@config:with_mode(Cfg, M) end
                        ),
                        gleam@result:map_error(
                            _pipe@2,
                            fun oaspec@config:error_to_string/1
                        )
                end, fun(Cfg@1) ->
                    Cfg@2 = case Output_opt of
                        none ->
                            Cfg@1;

                        {some, Path} ->
                            oaspec@config:with_output(Cfg@1, {some, Path})
                    end,
                    _pipe@3 = oaspec@config:validate_output_package_match(Cfg@2),
                    _pipe@4 = gleam@result:map(_pipe@3, fun(_) -> Cfg@2 end),
                    gleam@result:map_error(
                        _pipe@4,
                        fun oaspec@config:error_to_string/1
                    )
                end) end
    ).

-file("src/oaspec/cli.gleam", 91).
?DOC(" Create a config file template.\n").
-spec run_init(binary()) -> nil.
run_init(Path) ->
    Template = <<"# oaspec configuration file
# See https://github.com/nao1215/oaspec for documentation.

# Path to your OpenAPI 3.x specification (YAML or JSON).
input: openapi.yaml

# Gleam module namespace for generated code.
# Generated imports will be `import <package>/types`, etc.
package: api

# Generation mode: server, client, or both (default: both).
# mode: both

# Output settings (optional).
# output:
#   dir: ./gen                    # Base output directory (default: ./gen)
#   server: ./gen/api             # Override server output path
#   client: ./gen_client/api      # Override client output path
"/utf8>>,
    case simplifile_erl:is_file(Path) of
        {ok, true} ->
            gleam_stdlib:println(
                <<<<"Error: "/utf8, Path/binary>>/binary,
                    " already exists"/utf8>>
            ),
            erlang:halt(1);

        _ ->
            case simplifile:write(Path, Template) of
                {ok, _} ->
                    gleam_stdlib:println(<<"Created "/utf8, Path/binary>>);

                {error, _} ->
                    gleam_stdlib:println(
                        <<"Error: failed to write "/utf8, Path/binary>>
                    ),
                    erlang:halt(1)
            end
    end.

-file("src/oaspec/cli.gleam", 70).
?DOC(" The init command definition.\n").
-spec init_command() -> glint:command(nil).
init_command() ->
    begin
        glint:flag(
            begin
                _pipe = glint:string_flag(<<"output"/utf8>>),
                _pipe@1 = glint:flag_default(_pipe, <<"./oaspec.yaml"/utf8>>),
                glint:flag_help(
                    _pipe@1,
                    <<"Output path for the config file"/utf8>>
                )
            end,
            fun(Output_path) ->
                glint:command_help(
                    <<"Create a oaspec.yaml config file"/utf8>>,
                    fun() ->
                        glint:command(
                            fun(_, _, Flags) ->
                                Path = case Output_path(Flags) of
                                    {ok, P} ->
                                        P;

                                    {error, _} ->
                                        <<"./oaspec.yaml"/utf8>>
                                end,
                                run_init(Path)
                            end
                        )
                    end
                )
            end
        )
    end.

-file("src/oaspec/cli.gleam", 133).
?DOC(
    " Execute the generation pipeline.\n"
    " Handles IO (printing, exit codes) while delegating pure logic to\n"
    " generate.generate and load_config.\n"
).
-spec run_generate(
    binary(),
    gleam@option:option(binary()),
    gleam@option:option(binary())
) -> nil.
run_generate(Config_path, Mode_opt, Output_opt) ->
    gleam_stdlib:println(<<"oaspec v"/utf8, (<<"0.8.0"/utf8>>)/binary>>),
    gleam_stdlib:println(<<"Loading config from: "/utf8, Config_path/binary>>),
    case load_config(Config_path, Mode_opt, Output_opt) of
        {error, Msg} ->
            gleam_stdlib:println(<<"Error: "/utf8, Msg/binary>>),
            erlang:halt(1);

        {ok, Cfg} ->
            gleam_stdlib:println(
                <<"Parsing OpenAPI spec: "/utf8,
                    (erlang:element(2, Cfg))/binary>>
            ),
            case oaspec@openapi@parser:parse_file(erlang:element(2, Cfg)) of
                {error, E} ->
                    gleam_stdlib:println(
                        <<"Error: "/utf8,
                            (oaspec@openapi@parser:parse_error_to_string(E))/binary>>
                    ),
                    erlang:halt(1);

                {ok, Spec} ->
                    case oaspec@generate:generate(Spec, Cfg) of
                        {error, {validation_errors, Errors}} ->
                            gleam_stdlib:println(
                                <<"Error: OpenAPI spec contains unsupported features:"/utf8>>
                            ),
                            gleam@list:each(
                                Errors,
                                fun(E@1) ->
                                    gleam_stdlib:println(
                                        <<"  - "/utf8,
                                            (oaspec@codegen@validate:error_to_string(
                                                E@1
                                            ))/binary>>
                                    )
                                end
                            ),
                            erlang:halt(1);

                        {error, {resolve_error, Detail}} ->
                            gleam_stdlib:println(
                                <<"Error: Failed to resolve component aliases: "/utf8,
                                    Detail/binary>>
                            ),
                            erlang:halt(1);

                        {ok, Summary} ->
                            gleam_stdlib:println(
                                <<"Spec loaded: "/utf8,
                                    (erlang:element(3, Summary))/binary>>
                            ),
                            case erlang:element(4, Summary) of
                                [] ->
                                    nil;

                                Warnings ->
                                    gleam_stdlib:println(<<"Warnings:"/utf8>>),
                                    gleam@list:each(
                                        Warnings,
                                        fun(W) ->
                                            gleam_stdlib:println(
                                                <<"  - "/utf8,
                                                    (oaspec@codegen@validate:error_to_string(
                                                        W
                                                    ))/binary>>
                                            )
                                        end
                                    )
                            end,
                            gleam_stdlib:println(<<"Generating code..."/utf8>>),
                            case oaspec@codegen@writer:write_all(
                                erlang:element(2, Summary),
                                Cfg,
                                fun(Path) ->
                                    gleam_stdlib:println(
                                        <<"  Generated: "/utf8, Path/binary>>
                                    )
                                end
                            ) of
                                {ok, Written} ->
                                    gleam_stdlib:println(<<""/utf8>>),
                                    gleam_stdlib:println(
                                        <<<<"Successfully generated "/utf8,
                                                (erlang:integer_to_binary(
                                                    erlang:length(Written)
                                                ))/binary>>/binary,
                                            " files"/utf8>>
                                    );

                                {error, E@2} ->
                                    gleam_stdlib:println(
                                        <<"Error: "/utf8,
                                            (oaspec@codegen@writer:error_to_string(
                                                E@2
                                            ))/binary>>
                                    ),
                                    erlang:halt(1)
                            end
                    end
            end
    end.

-file("src/oaspec/cli.gleam", 26).
?DOC(" The generate command definition.\n").
-spec generate_command() -> glint:command(nil).
generate_command() ->
    begin
        glint:flag(
            begin
                _pipe = glint:string_flag(<<"config"/utf8>>),
                _pipe@1 = glint:flag_default(_pipe, <<"./oaspec.yaml"/utf8>>),
                glint:flag_help(_pipe@1, <<"Path to config file"/utf8>>)
            end,
            fun(Config_path) ->
                glint:flag(
                    begin
                        _pipe@2 = glint:string_flag(<<"mode"/utf8>>),
                        _pipe@3 = glint:flag_default(_pipe@2, <<""/utf8>>),
                        glint:flag_help(
                            _pipe@3,
                            <<"Generation mode: server, client, or both (overrides config)"/utf8>>
                        )
                    end,
                    fun(Mode) ->
                        glint:flag(
                            begin
                                _pipe@4 = glint:string_flag(<<"output"/utf8>>),
                                _pipe@5 = glint:flag_default(
                                    _pipe@4,
                                    <<""/utf8>>
                                ),
                                glint:flag_help(
                                    _pipe@5,
                                    <<"Output directory override"/utf8>>
                                )
                            end,
                            fun(Output) ->
                                glint:command_help(
                                    <<"Generate Gleam code from an OpenAPI specification"/utf8>>,
                                    fun() ->
                                        glint:command(
                                            fun(_, _, Flags) ->
                                                Config_path@1 = begin
                                                    _pipe@6 = Config_path(Flags),
                                                    gleam@result:unwrap(
                                                        _pipe@6,
                                                        <<"./oaspec.yaml"/utf8>>
                                                    )
                                                end,
                                                Mode_opt = case begin
                                                    _pipe@7 = Mode(Flags),
                                                    gleam@result:unwrap(
                                                        _pipe@7,
                                                        <<""/utf8>>
                                                    )
                                                end of
                                                    <<""/utf8>> ->
                                                        none;

                                                    S ->
                                                        {some, S}
                                                end,
                                                Output_opt = case begin
                                                    _pipe@8 = Output(Flags),
                                                    gleam@result:unwrap(
                                                        _pipe@8,
                                                        <<""/utf8>>
                                                    )
                                                end of
                                                    <<""/utf8>> ->
                                                        none;

                                                    S@1 ->
                                                        {some, S@1}
                                                end,
                                                run_generate(
                                                    Config_path@1,
                                                    Mode_opt,
                                                    Output_opt
                                                )
                                            end
                                        )
                                    end
                                )
                            end
                        )
                    end
                )
            end
        )
    end.

-file("src/oaspec/cli.gleam", 16).
?DOC(" Set up the CLI application.\n").
-spec app() -> glint:glint(nil).
app() ->
    _pipe = glint:new(),
    _pipe@1 = glint:with_name(_pipe, <<"oaspec"/utf8>>),
    _pipe@2 = glint:global_help(
        _pipe@1,
        <<"Generate Gleam code from OpenAPI 3.x specifications"/utf8>>
    ),
    _pipe@3 = glint:pretty_help(_pipe@2, glint:default_pretty_help()),
    _pipe@4 = glint:add(_pipe@3, [<<"generate"/utf8>>], generate_command()),
    glint:add(_pipe@4, [<<"init"/utf8>>], init_command()).