gilly

-module(gilly).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gilly.gleam").
-export([main/0]).
-export_type([args/0]).

-type args() :: {generate,
        binary(),
        gleam@option:option(binary()),
        gilly@internal@codegen:optionality(),
        integer(),
        boolean()} |
    version.

-file("src/gilly.gleam", 28).
-spec source_arg() -> clip@arg:arg(binary()).
source_arg() ->
    _pipe = clip@arg:new(<<"source"/utf8>>),
    clip@arg:help(
        _pipe,
        <<"Path to the OpenAPI specification file (JSON)"/utf8>>
    ).

-file("src/gilly.gleam", 33).
-spec output_opt() -> clip@opt:opt(gleam@option:option(binary())).
output_opt() ->
    _pipe = clip@opt:new(<<"output"/utf8>>),
    _pipe@1 = clip@opt:short(_pipe, <<"o"/utf8>>),
    _pipe@2 = clip@opt:help(
        _pipe@1,
        <<"Output file path (prints to stdout if omitted)"/utf8>>
    ),
    _pipe@3 = clip@opt:map(_pipe@2, fun(Field@0) -> {some, Field@0} end),
    clip@opt:default(_pipe@3, none).

-file("src/gilly.gleam", 41).
-spec optionality_opt() -> clip@opt:opt(gilly@internal@codegen:optionality()).
optionality_opt() ->
    _pipe = clip@opt:new(<<"optionality"/utf8>>),
    _pipe@1 = clip@opt:help(
        _pipe,
        <<"How to determine optional fields:
    - RequiredOnly: Only fields that are required in the OpenAPI spec are non-optional (default)
    - NullableOnly: Fields are optional if they are marked `nullable: true`
    - RequiredAndNullable: Fields are optional if they are either not required or marked `nullable: true`
"/utf8>>
    ),
    _pipe@2 = clip@opt:try_map(_pipe@1, fun(S) -> case S of
                <<"RequiredOnly"/utf8>> ->
                    {ok, required_only};

                <<"NullableOnly"/utf8>> ->
                    {ok, nullable_only};

                <<"RequiredAndNullable"/utf8>> ->
                    {ok, required_and_nullable};

                _ ->
                    {error,
                        <<<<"Invalid optionality: '"/utf8, S/binary>>/binary,
                            "'. Must be one of: RequiredOnly, NullableOnly, RequiredAndNullable"/utf8>>}
            end end),
    clip@opt:default(_pipe@2, required_only).

-file("src/gilly.gleam", 66).
-spec indent_opt() -> clip@opt:opt(integer()).
indent_opt() ->
    _pipe = clip@opt:new(<<"indent"/utf8>>),
    _pipe@1 = clip@opt:help(
        _pipe,
        <<"Number of spaces for indentation (default: 2)"/utf8>>
    ),
    _pipe@2 = clip@opt:int(_pipe@1),
    clip@opt:default(_pipe@2, 2).

-file("src/gilly.gleam", 73).
-spec optional_query_params_flag() -> clip@flag:flag().
optional_query_params_flag() ->
    _pipe = clip@flag:new(<<"optional-query-params"/utf8>>),
    _pipe@1 = clip@flag:short(_pipe, <<"q"/utf8>>),
    clip@flag:help(
        _pipe@1,
        <<"Make query parameters optional (default: false)"/utf8>>
    ).

-file("src/gilly.gleam", 79).
-spec generate_command() -> clip:command(args()).
generate_command() ->
    _pipe = clip:command(
        begin
            clip:parameter(
                fun(Source) ->
                    clip:parameter(
                        fun(Output) ->
                            clip:parameter(
                                fun(Optionality) ->
                                    clip:parameter(
                                        fun(Indent) ->
                                            clip:parameter(
                                                fun(Optional_query_params) ->
                                                    {generate,
                                                        Source,
                                                        Output,
                                                        Optionality,
                                                        Indent,
                                                        Optional_query_params}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ),
    _pipe@1 = clip:arg(_pipe, source_arg()),
    _pipe@2 = clip:opt(_pipe@1, output_opt()),
    _pipe@3 = clip:opt(_pipe@2, optionality_opt()),
    _pipe@4 = clip:opt(_pipe@3, indent_opt()),
    _pipe@5 = clip:flag(_pipe@4, optional_query_params_flag()),
    clip:help(
        _pipe@5,
        clip@help:simple(
            <<"generate"/utf8>>,
            <<"Generate code from an OpenAPI specification"/utf8>>
        )
    ).

-file("src/gilly.gleam", 99).
-spec version_command() -> clip:command(args()).
version_command() ->
    _pipe = clip:return(version),
    clip:help(
        _pipe,
        clip@help:simple(
            <<"version"/utf8>>,
            <<"Print the version of Gilly"/utf8>>
        )
    ).

-file("src/gilly.gleam", 104).
-spec command() -> clip:command(args()).
command() ->
    clip:subcommands_with_default(
        [{<<"generate"/utf8>>, generate_command()},
            {<<"version"/utf8>>, version_command()}],
        generate_command()
    ).

-file("src/gilly.gleam", 129).
-spec run(args()) -> nil.
run(Args) ->
    case Args of
        version ->
            gleam_stdlib:println(<<"Gilly version "/utf8, "0.1.8"/utf8>>);

        {generate, Source, Output, Optionality, Indent, Optional_query_params} ->
            Builder = begin
                _pipe = gilly@internal@gilly:new(),
                _pipe@1 = gilly@internal@gilly:with_version(
                    _pipe,
                    <<"0.1.8"/utf8>>
                ),
                _pipe@2 = gilly@internal@gilly:with_optionality(
                    _pipe@1,
                    Optionality
                ),
                _pipe@3 = gilly@internal@gilly:with_indent(_pipe@2, Indent),
                gilly@internal@gilly:with_optional_query_params(
                    _pipe@3,
                    Optional_query_params
                )
            end,
            case gilly@internal@gilly:generate_code_from_file(Builder, Source) of
                {ok, Code} ->
                    case Output of
                        {some, Path} ->
                            _ = begin
                                _pipe@4 = simplifile:write(Path, Code),
                                gleam@result:map_error(
                                    _pipe@4,
                                    fun(E) ->
                                        gleam_stdlib:println_error(
                                            <<"Error writing file: "/utf8,
                                                (simplifile:describe_error(E))/binary>>
                                        )
                                    end
                                )
                            end,
                            nil;

                        none ->
                            gleam_stdlib:println(Code)
                    end;

                {error, E@1} ->
                    gleam_stdlib:println_error(
                        <<"Error generating code: "/utf8,
                            (gilly@internal@error:describe_error(E@1))/binary>>
                    )
            end
    end.

-file("src/gilly.gleam", 114).
-spec main() -> nil.
main() ->
    Result = begin
        _pipe = command(),
        _pipe@1 = clip:help(
            _pipe,
            clip@help:simple(
                <<"gilly"/utf8>>,
                <<"A code generator that produces type-safe API clients from OpenAPI specifications."/utf8>>
            )
        ),
        clip:run(_pipe@1, erlang:element(4, argv:load()))
    end,
    case Result of
        {error, E} ->
            gleam_stdlib:println_error(E);

        {ok, Args} ->
            run(Args)
    end.