builder

-module(builder@simulate).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/builder/simulate.gleam").
-export([simulate_builder_run/6]).
-export_type([virtual_module/0, virtual_file/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 virtual_module() :: {virtual_module,
        binary(),
        binary(),
        binary(),
        binary()}.

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

-file("src/builder/simulate.gleam", 22).
-spec create_virtal_modules(list(virtual_module())) -> {ok,
        gleam@dict:dict(binary(), builder@module:module_())} |
    {error, builder@internal@analyzer:error()}.
create_virtal_modules(Modules) ->
    _pipe = gleam@list:try_map(
        Modules,
        fun(Module) ->
            builder@internal@analyzer:analyze_module_contents(
                erlang:element(2, Module),
                erlang:element(3, Module),
                erlang:element(4, Module),
                erlang:element(5, Module)
            )
        end
    ),
    gleam@result:map(
        _pipe,
        fun(Modules@1) ->
            _pipe@1 = gleam@list:map(
                Modules@1,
                fun(Module@1) -> {erlang:element(4, Module@1), Module@1} end
            ),
            maps:from_list(_pipe@1)
        end
    ).

-file("src/builder/simulate.gleam", 45).
?DOC(
    " Run builders in a simulated environment for testing purposes only\n"
    "\n"
    " Creates a virtual build context with in-memory files instead of touching\n"
    " the real file system. Useful for unit testing builders without side effects.\n"
).
-spec simulate_builder_run(
    list(builder@core:builder()),
    list(virtual_file()),
    fun((builder@context:build_context(), builder@asset:build_asset()) -> {ok,
            gleam@option:option(binary())} |
        {error, builder@context:error()}),
    fun((builder@context:build_context(), builder@asset:build_asset()) -> {ok,
            gleam@option:option(bitstring())} |
        {error, builder@context:error()}),
    fun((builder@context:build_context(), builder@asset:build_asset(), binary()) -> {ok,
            nil} |
        {error, builder@context:error()}),
    fun((builder@context:build_context(), builder@asset:build_asset(), bitstring()) -> {ok,
            nil} |
        {error, builder@context:error()})
) -> nil.
simulate_builder_run(
    Builders,
    Project_files,
    Read,
    Read_bits,
    Write,
    Write_bits
) ->
    File_paths = begin
        _pipe = Project_files,
        gleam@list:map(_pipe, fun(File) -> erlang:element(2, File) end)
    end,
    Project_modules@1 = case create_virtal_modules(
        begin
            _pipe@1 = Project_files,
            gleam@list:filter_map(
                _pipe@1,
                fun(File@1) ->
                    case filepath:extension(erlang:element(2, File@1)) =:= {ok,
                        <<"gleam"/utf8>>} of
                        true ->
                            {ok,
                                {virtual_module,
                                    erlang:element(3, File@1),
                                    begin
                                        _pipe@2 = builder@internal@util:trim_prefix(
                                            erlang:element(2, File@1),
                                            <<"/"/utf8>>
                                        ),
                                        filepath:strip_extension(_pipe@2)
                                    end,
                                    <<"simulated"/utf8>>,
                                    erlang:element(2, File@1)}};

                        _ ->
                            {error, nil}
                    end
                end
            )
        end
    ) of
        {ok, Project_modules} -> Project_modules;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"builder/simulate"/utf8>>,
                        function => <<"simulate_builder_run"/utf8>>,
                        line => 59,
                        value => _assert_fail,
                        start => 1736,
                        'end' => 2242,
                        pattern_start => 1747,
                        pattern_end => 1766})
    end,
    Build_context = builder@context:new_dummy_build_context(
        Project_modules@1,
        fun(Ctx, Asset) -> case Read(Ctx, Asset) of
                {ok, none} ->
                    {error, {file_error, eio}};

                {ok, {some, Val}} ->
                    {ok, Val};

                {error, Err} ->
                    {error, Err}
            end end,
        fun(Ctx@1, Asset@1) -> case Read_bits(Ctx@1, Asset@1) of
                {ok, none} ->
                    {error, {file_error, eio}};

                {ok, {some, Val@1}} ->
                    {ok, Val@1};

                {error, Err@1} ->
                    {error, Err@1}
            end end,
        fun(Ctx@2, Asset@2, Contents) -> Write(Ctx@2, Asset@2, Contents) end,
        fun(Ctx@3, Asset@3, Bits) -> Write_bits(Ctx@3, Asset@3, Bits) end
    ),
    builder@core:run_builders(Builders, Build_context, File_paths),
    nil.