-module(oaspec@codegen@writer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/oaspec/codegen/writer.gleam").
-export([generate_all/2, error_to_string/1]).
-export_type([write_error/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.

-type write_error() :: {directory_create_error, binary(), binary()} |
    {file_write_error, binary(), binary()}.

-file("src/oaspec/codegen/writer.gleam", 66).
?DOC(" Generate shared files (types, decoders, encoders, middleware).\n").
-spec generate_shared(oaspec@codegen@context:context()) -> list(oaspec@codegen@context:generated_file()).
generate_shared(Ctx) ->
    Type_files = oaspec@codegen@types:generate(Ctx),
    Decoder_files = oaspec@codegen@decoders:generate(Ctx),
    Middleware_files = oaspec@codegen@middleware:generate(Ctx),
    Guard_files = oaspec@codegen@guards:generate(Ctx),
    lists:append([Type_files, Decoder_files, Middleware_files, Guard_files]).

-file("src/oaspec/codegen/writer.gleam", 76).
?DOC(" Ensure a directory exists, creating it if necessary.\n").
-spec ensure_directory(binary()) -> {ok, nil} | {error, write_error()}.
ensure_directory(Path) ->
    _pipe = simplifile:create_directory_all(Path),
    gleam@result:map_error(
        _pipe,
        fun(_) ->
            {directory_create_error,
                Path,
                <<"Failed to create directory"/utf8>>}
        end
    ).

-file("src/oaspec/codegen/writer.gleam", 84).
?DOC(" Write a list of generated files to a directory.\n").
-spec write_files(
    list(oaspec@codegen@context:generated_file()),
    binary(),
    list(binary()),
    fun((binary()) -> nil)
) -> {ok, list(binary())} | {error, write_error()}.
write_files(Files, Base_path, Written, On_write) ->
    gleam@list:try_fold(
        Files,
        Written,
        fun(Acc, File) ->
            Full_path = <<<<Base_path/binary, "/"/utf8>>/binary,
                (erlang:element(2, File))/binary>>,
            gleam@result:'try'(
                begin
                    _pipe = simplifile:write(Full_path, erlang:element(3, File)),
                    gleam@result:map_error(
                        _pipe,
                        fun(_) ->
                            {file_write_error,
                                Full_path,
                                <<"Failed to write file"/utf8>>}
                        end
                    )
                end,
                fun(_) ->
                    On_write(Full_path),
                    {ok, [Full_path | Acc]}
                end
            )
        end
    ).

-file("src/oaspec/codegen/writer.gleam", 20).
?DOC(" Generate and write all files based on configuration.\n").
-spec generate_all(oaspec@codegen@context:context(), fun((binary()) -> nil)) -> {ok,
        list(binary())} |
    {error, write_error()}.
generate_all(Ctx, On_write) ->
    Shared_files = generate_shared(Ctx),
    Server_files = case erlang:element(6, erlang:element(3, Ctx)) of
        server ->
            oaspec@codegen@server:generate(Ctx);

        both ->
            oaspec@codegen@server:generate(Ctx);

        client ->
            []
    end,
    Client_files = case erlang:element(6, erlang:element(3, Ctx)) of
        client ->
            oaspec@codegen@client:generate(Ctx);

        both ->
            oaspec@codegen@client:generate(Ctx);

        server ->
            []
    end,
    Server_path = erlang:element(3, erlang:element(3, Ctx)),
    Client_path = erlang:element(4, erlang:element(3, Ctx)),
    Written_files = [],
    gleam@result:'try'(case erlang:element(6, erlang:element(3, Ctx)) of
            server ->
                gleam@result:'try'(
                    ensure_directory(Server_path),
                    fun(_) ->
                        _pipe = write_files(
                            Shared_files,
                            Server_path,
                            Written_files,
                            On_write
                        ),
                        gleam@result:'try'(
                            _pipe,
                            fun(W) ->
                                write_files(
                                    Server_files,
                                    Server_path,
                                    W,
                                    On_write
                                )
                            end
                        )
                    end
                );

            both ->
                gleam@result:'try'(
                    ensure_directory(Server_path),
                    fun(_) ->
                        _pipe = write_files(
                            Shared_files,
                            Server_path,
                            Written_files,
                            On_write
                        ),
                        gleam@result:'try'(
                            _pipe,
                            fun(W) ->
                                write_files(
                                    Server_files,
                                    Server_path,
                                    W,
                                    On_write
                                )
                            end
                        )
                    end
                );

            client ->
                {ok, Written_files}
        end, fun(Written_files@1) ->
            gleam@result:'try'(case erlang:element(6, erlang:element(3, Ctx)) of
                    client ->
                        gleam@result:'try'(
                            ensure_directory(Client_path),
                            fun(_) ->
                                _pipe@1 = write_files(
                                    Shared_files,
                                    Client_path,
                                    Written_files@1,
                                    On_write
                                ),
                                gleam@result:'try'(
                                    _pipe@1,
                                    fun(W@1) ->
                                        write_files(
                                            Client_files,
                                            Client_path,
                                            W@1,
                                            On_write
                                        )
                                    end
                                )
                            end
                        );

                    both ->
                        gleam@result:'try'(
                            ensure_directory(Client_path),
                            fun(_) ->
                                _pipe@1 = write_files(
                                    Shared_files,
                                    Client_path,
                                    Written_files@1,
                                    On_write
                                ),
                                gleam@result:'try'(
                                    _pipe@1,
                                    fun(W@1) ->
                                        write_files(
                                            Client_files,
                                            Client_path,
                                            W@1,
                                            On_write
                                        )
                                    end
                                )
                            end
                        );

                    server ->
                        {ok, Written_files@1}
                end, fun(Written_files@2) -> {ok, Written_files@2} end)
        end).

-file("src/oaspec/codegen/writer.gleam", 104).
?DOC(" Convert a write error to a human-readable string.\n").
-spec error_to_string(write_error()) -> binary().
error_to_string(Error) ->
    case Error of
        {directory_create_error, Path, Detail} ->
            <<<<<<"Failed to create directory "/utf8, Path/binary>>/binary,
                    ": "/utf8>>/binary,
                Detail/binary>>;

        {file_write_error, Path@1, Detail@1} ->
            <<<<<<"Failed to write file "/utf8, Path@1/binary>>/binary,
                    ": "/utf8>>/binary,
                Detail@1/binary>>
    end.