builder

-module(builder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/builder.gleam").
-export([new_generic_builder/2, new_generic_multiple_builder/2, new_gleam_builder/1, new_gleam_multiple_builder/1, execute_builders/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/builder.gleam", 17).
?DOC(" Execute a build function on each files matching the source extensions\n").
-spec new_generic_builder(
    list(binary()),
    fun((builder@context:build_context(), builder@asset:build_asset()) -> nil)
) -> builder@core:builder().
new_generic_builder(Source_extensions, Build) ->
    {single_file_builder, Source_extensions, Build}.

-file("src/builder.gleam", 25).
?DOC(" Execute a unique build function on multiple files in one step\n").
-spec new_generic_multiple_builder(
    list(binary()),
    fun((builder@context:build_context(), list(builder@asset:build_asset())) -> nil)
) -> builder@core:builder().
new_generic_multiple_builder(Source_extensions, Build) ->
    {multiple_files_builder, Source_extensions, Build}.

-file("src/builder.gleam", 33).
?DOC(" Execute a build function on every gleam files\n").
-spec new_gleam_builder(
    fun((builder@context:build_context(), builder@asset:gleam_asset()) -> nil)
) -> builder@core:builder().
new_gleam_builder(Build) ->
    new_generic_builder(
        [<<"gleam"/utf8>>],
        fun(Ctx, File) ->
            Modules = maps:to_list(builder@context:modules(Ctx)),
            case begin
                _pipe = gleam@list:find_map(
                    Modules,
                    fun(Entry) ->
                        Module = erlang:element(2, Entry),
                        case erlang:element(11, Module) =:= erlang:element(
                            2,
                            File
                        ) of
                            true ->
                                {ok, Module};

                            false ->
                                {error, nil}
                        end
                    end
                ),
                gleam@result:map(
                    _pipe,
                    fun(Module@1) -> {gleam_build_asset, Module@1, File} end
                )
            end of
                {ok, Asset} ->
                    Build(Ctx, Asset);

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

-file("src/builder.gleam", 56).
?DOC(" Execute a unique build function on multiple files\n").
-spec new_gleam_multiple_builder(
    fun((builder@context:build_context(), list(builder@asset:gleam_asset())) -> nil)
) -> builder@core:builder().
new_gleam_multiple_builder(Build) ->
    new_generic_multiple_builder(
        [<<"gleam"/utf8>>],
        fun(Ctx, Files) ->
            Modules = maps:to_list(builder@context:modules(Ctx)),
            Build(
                Ctx,
                gleam@list:filter_map(
                    Files,
                    fun(File) ->
                        _pipe = gleam@list:find_map(
                            Modules,
                            fun(Entry) ->
                                Module = erlang:element(2, Entry),
                                case erlang:element(11, Module) =:= erlang:element(
                                    2,
                                    File
                                ) of
                                    true ->
                                        {ok, Module};

                                    false ->
                                        {error, nil}
                                end
                            end
                        ),
                        gleam@result:map(
                            _pipe,
                            fun(Module@1) ->
                                {gleam_build_asset, Module@1, File}
                            end
                        )
                    end
                )
            )
        end
    ).

-file("src/builder.gleam", 122).
-spec process_builders(list(builder@core:builder())) -> nil.
process_builders(Builders) ->
    gleam_stdlib:println(<<"Process builders"/utf8>>),
    Source_directory = filepath:join(
        builder@internal@util:find_current_project_root_path(),
        <<"src"/utf8>>
    ),
    Files = builder@internal@util:scan_walk(Source_directory),
    Project_modules = builder@internal@analyzer:analyze_project(
        Source_directory
    ),
    Build_context = builder@context:new_build_context(Project_modules),
    builder@core:run_builders(Builders, Build_context, Files),
    nil.

-file("src/builder.gleam", 92).
-spec watch_builders(list(builder@core:builder())) -> nil.
watch_builders(Builders) ->
    gleam_stdlib:println(<<"Start builders watcher"/utf8>>),
    Source_directory = filepath:join(
        builder@internal@util:find_current_project_root_path(),
        <<"src"/utf8>>
    ),
    Watcher = begin
        _pipe = polly:new(),
        _pipe@1 = polly:add_dir(_pipe, Source_directory),
        _pipe@2 = polly:interval(_pipe@1, 100),
        _pipe@3 = polly:add_callback(_pipe@2, fun(Event) -> case Event of
                    {changed, _} ->
                        process_builders(Builders);

                    {created, _} ->
                        process_builders(Builders);

                    {deleted, _} ->
                        process_builders(Builders);

                    {error, _, _} ->
                        nil
                end end),
        polly:supervised(_pipe@3)
    end,
    case begin
        _pipe@4 = gleam@otp@static_supervisor:new(one_for_one),
        _pipe@5 = gleam@otp@static_supervisor:add(_pipe@4, Watcher),
        gleam@otp@static_supervisor:start(_pipe@5)
    end of
        {ok, _} -> nil;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"builder"/utf8>>,
                        function => <<"watch_builders"/utf8>>,
                        line => 112,
                        value => _assert_fail,
                        start => 3116,
                        'end' => 3258,
                        pattern_start => 3127,
                        pattern_end => 3132})
    end,
    gleam_erlang_ffi:sleep_forever(),
    nil.

-file("src/builder.gleam", 83).
?DOC(
    " Execute the provided list of builders\n"
    "\n"
    " When run with the \"watch\" argument, starts a file watcher that continuously\n"
    " monitors the source directory and rebuilds on changes. Otherwise, performs\n"
    " a single build pass.\n"
).
-spec execute_builders(list(builder@core:builder())) -> nil.
execute_builders(Builders) ->
    case erlang:element(4, argv:load()) of
        [<<"watch"/utf8>> | _] ->
            watch_builders(Builders);

        _ ->
            process_builders(Builders)
    end,
    nil.