-module(proute).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/proute.gleam").
-export([run_config/1, main/0]).
-export_type([generated_mount/0, generated_file/0, proute_error/0]).

-type generated_mount() :: {generated_mount, list(generated_file())}.

-type generated_file() :: {generated_file, binary(), binary()}.

-type proute_error() :: {config_error, proute@config:config_error()} |
    {discovery_error, proute@discover:discover_error()} |
    {validation_errors, list(proute@validate@pages:validation_error())} |
    {write_error, binary()}.

-file("src/proute.gleam", 137).
-spec describe_error(proute_error()) -> binary().
describe_error(Error) ->
    case Error of
        {config_error, Error@1} ->
            proute@config:describe_error(Error@1);

        {discovery_error, Error@2} ->
            proute@discover:describe_error(Error@2);

        {validation_errors, Errors} ->
            _pipe = Errors,
            _pipe@1 = gleam@list:map(
                _pipe,
                fun proute@validate@pages:describe_error/1
            ),
            gleam@string:join(_pipe@1, <<"\n"/utf8>>);

        {write_error, Path} ->
            <<<<"Could not write generated file "/utf8,
                    (gleam@string:inspect(Path))/binary>>/binary,
                "."/utf8>>
    end.

-file("src/proute.gleam", 127).
-spec write_file(binary(), binary()) -> {ok, nil} | {error, proute_error()}.
write_file(Path, Contents) ->
    gleam@result:'try'(
        begin
            _pipe = simplifile:create_directory_all(
                filepath:directory_name(Path)
            ),
            gleam@result:map_error(_pipe, fun(_) -> {write_error, Path} end)
        end,
        fun(_) -> _pipe@1 = simplifile:write(Path, Contents),
            gleam@result:map_error(_pipe@1, fun(_) -> {write_error, Path} end) end
    ).

-file("src/proute.gleam", 113).
-spec write_all(list(generated_file())) -> {ok, list(generated_file())} |
    {error, proute_error()}.
write_all(Files) ->
    gleam@result:'try'(
        begin
            _pipe = Files,
            gleam@list:try_map(
                _pipe,
                fun(File) ->
                    {generated_file, Path, Contents} = File,
                    write_file(Path, Contents)
                end
            )
        end,
        fun(_) -> {ok, Files} end
    ).

-file("src/proute.gleam", 81).
-spec generate_mount(proute@config:mount()) -> {ok, generated_mount()} |
    {error, proute_error()}.
generate_mount(Mount) ->
    gleam@result:'try'(
        begin
            _pipe = proute@discover:discover_mount(Mount),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {discovery_error, Field@0} end
            )
        end,
        fun(Mount_routes) ->
            gleam@result:'try'(
                begin
                    _pipe@1 = proute@validate@pages:validate_mount(Mount_routes),
                    gleam@result:map_error(
                        _pipe@1,
                        fun(Field@0) -> {validation_errors, Field@0} end
                    )
                end,
                fun(Page_modules) ->
                    {ok,
                        {generated_mount,
                            [{generated_file,
                                    erlang:element(6, Mount),
                                    proute@generate@routes:generate(
                                        Mount_routes
                                    )},
                                {generated_file,
                                    erlang:element(8, Mount),
                                    proute@generate@page_input:generate(
                                        Mount_routes
                                    )},
                                {generated_file,
                                    erlang:element(7, Mount),
                                    proute@generate@pages:generate(
                                        Mount_routes,
                                        Page_modules,
                                        erlang:element(10, Mount)
                                    )}]}}
                end
            )
        end
    ).

-file("src/proute.gleam", 70).
-spec generate_all(proute@config:config()) -> {ok, list(generated_file())} |
    {error, proute_error()}.
generate_all(Config) ->
    gleam@result:'try'(
        begin
            _pipe = erlang:element(4, Config),
            gleam@list:try_map(_pipe, fun generate_mount/1)
        end,
        fun(Generated) ->
            {ok,
                begin
                    _pipe@1 = Generated,
                    gleam@list:flat_map(
                        _pipe@1,
                        fun(Mount) -> erlang:element(2, Mount) end
                    )
                end}
        end
    ).

-file("src/proute.gleam", 50).
-spec run_config(proute@config:config()) -> {ok, list(generated_file())} |
    {error, proute_error()}.
run_config(Config) ->
    gleam@result:'try'(
        generate_all(Config),
        fun(Generated) ->
            gleam@result:'try'(
                write_all(Generated),
                fun(Files) -> {ok, Files} end
            )
        end
    ).

-file("src/proute.gleam", 157).
-spec find_config_path_from(binary()) -> {ok, binary()} | {error, nil}.
find_config_path_from(Directory) ->
    Path = <<Directory/binary, "/proute.toml"/utf8>>,
    case simplifile_erl:is_file(Path) of
        {ok, true} ->
            {ok, Path};

        _ ->
            Parent = filepath:directory_name(Directory),
            case Parent =:= Directory of
                true ->
                    {error, nil};

                false ->
                    find_config_path_from(Parent)
            end
    end.

-file("src/proute.gleam", 150).
-spec find_config_path() -> {ok, binary()} | {error, nil}.
find_config_path() ->
    case simplifile:current_directory() of
        {ok, Directory} ->
            find_config_path_from(Directory);

        {error, _} ->
            {error, nil}
    end.

-file("src/proute.gleam", 59).
-spec load() -> {ok, proute@config:config()} |
    {error, proute@config:config_error()}.
load() ->
    case find_config_path() of
        {ok, Path} ->
            case simplifile:read(Path) of
                {ok, Source} ->
                    proute@config:parse(Source);

                {error, _} ->
                    {error, {missing_config, Path}}
            end;

        {error, _} ->
            {error, {missing_config, <<"proute.toml"/utf8>>}}
    end.

-file("src/proute.gleam", 45).
-spec run() -> {ok, list(generated_file())} | {error, proute_error()}.
run() ->
    gleam@result:'try'(
        begin
            _pipe = load(),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {config_error, Field@0} end
            )
        end,
        fun(Config) -> run_config(Config) end
    ).

-file("src/proute.gleam", 30).
-spec main() -> nil.
main() ->
    case run() of
        {ok, Files} ->
            _pipe = Files,
            gleam@list:each(
                _pipe,
                fun(File) ->
                    {generated_file, Path, _} = File,
                    gleam_stdlib:println(<<"Generated "/utf8, Path/binary>>)
                end
            );

        {error, Error} ->
            gleam_stdlib:println_error(describe_error(Error)),
            proute@exit:failure()
    end.