-module(caffeine_lang@parser@linker).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/parser/linker.gleam").
-export([get_instantiation_json_files/1, link/2]).

-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/caffeine_lang/parser/linker.gleam", 57).
-spec read_directory_or_error(binary()) -> {ok, list(binary())} |
    {error, binary()}.
read_directory_or_error(Directory_path) ->
    case simplifile_erl:read_directory(Directory_path) of
        {ok, Items} ->
            {ok, Items};

        {error, Err} ->
            {error,
                <<<<<<(simplifile:describe_error(Err))/binary, " ("/utf8>>/binary,
                        Directory_path/binary>>/binary,
                    ")"/utf8>>}
    end.

-file("src/caffeine_lang/parser/linker.gleam", 109).
-spec extract_json_files_with_full_paths(list(binary()), binary()) -> list(binary()).
extract_json_files_with_full_paths(Files, Directory_path) ->
    _pipe = Files,
    _pipe@1 = gleam@list:filter(
        _pipe,
        fun(File) -> gleam_stdlib:string_ends_with(File, <<".json"/utf8>>) end
    ),
    gleam@list:map(
        _pipe@1,
        fun(File@1) ->
            <<<<Directory_path/binary, "/"/utf8>>/binary, File@1/binary>>
        end
    ).

-file("src/caffeine_lang/parser/linker.gleam", 85).
-spec collect_json_files_from_subdirectory(binary(), list(binary())) -> {ok,
        list(binary())} |
    {error, binary()}.
collect_json_files_from_subdirectory(Subdirectory_path, Accumulated_files) ->
    gleam@result:'try'(
        read_directory_or_error(Subdirectory_path),
        fun(Items_in_subdirectory) -> _pipe = Items_in_subdirectory,
            gleam@list:try_fold(
                _pipe,
                Accumulated_files,
                fun(Acc, Item_name) ->
                    Nested_path = <<<<Subdirectory_path/binary, "/"/utf8>>/binary,
                        Item_name/binary>>,
                    case simplifile_erl:is_directory(Nested_path) of
                        {ok, true} ->
                            gleam@result:'try'(
                                read_directory_or_error(Nested_path),
                                fun(Files_in_nested) ->
                                    Json_files = extract_json_files_with_full_paths(
                                        Files_in_nested,
                                        Nested_path
                                    ),
                                    {ok, lists:append(Acc, Json_files)}
                                end
                            );

                        _ ->
                            {ok, Acc}
                    end
                end
            ) end
    ).

-file("src/caffeine_lang/parser/linker.gleam", 70).
-spec process_top_level_item(binary(), binary(), list(binary())) -> {ok,
        list(binary())} |
    {error, binary()}.
process_top_level_item(Base_directory, Item_name, Accumulated_files) ->
    Item_path = <<<<Base_directory/binary, "/"/utf8>>/binary, Item_name/binary>>,
    case simplifile_erl:is_directory(Item_path) of
        {ok, true} ->
            collect_json_files_from_subdirectory(Item_path, Accumulated_files);

        _ ->
            {ok, Accumulated_files}
    end.

-file("src/caffeine_lang/parser/linker.gleam", 120).
?DOC(false).
-spec get_instantiation_json_files(binary()) -> {ok, list(binary())} |
    {error, binary()}.
get_instantiation_json_files(Base_directory) ->
    gleam@result:'try'(
        read_directory_or_error(Base_directory),
        fun(Top_level_items) -> _pipe = Top_level_items,
            gleam@list:try_fold(
                _pipe,
                [],
                fun(Accumulated_files, Item_name) ->
                    process_top_level_item(
                        Base_directory,
                        Item_name,
                        Accumulated_files
                    )
                end
            ) end
    ).

-file("src/caffeine_lang/parser/linker.gleam", 33).
-spec fetch_expectations(
    binary(),
    list(caffeine_lang@parser@blueprints:blueprint())
) -> {ok,
        list(caffeine_lang@middle_end@semantic_analyzer:intermediate_representation())} |
    {error, caffeine_lang@common@errors:compilation_error()}.
fetch_expectations(Expectations_directory, Blueprints) ->
    caffeine_lang@common@helpers:result_try(
        begin
            _pipe = get_instantiation_json_files(Expectations_directory),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {linker_parse_error, Field@0} end
            )
        end,
        fun(Expectations_files) -> case Expectations_files of
                [] ->
                    {error,
                        {linker_parse_error,
                            <<"No expectation files found in: "/utf8,
                                Expectations_directory/binary>>}};

                _ ->
                    _pipe@1 = Expectations_files,
                    _pipe@2 = gleam@list:map(
                        _pipe@1,
                        fun(File_path) ->
                            caffeine_lang@parser@expectations:parse_from_file(
                                File_path,
                                Blueprints
                            )
                        end
                    ),
                    _pipe@3 = gleam@result:all(_pipe@2),
                    gleam@result:map(_pipe@3, fun lists:append/1)
            end end
    ).

-file("src/caffeine_lang/parser/linker.gleam", 22).
?DOC(
    " Link will fetch, then parse all configuration files, combining them into one single\n"
    " list of intermediate representation objects. In the future how we fetch these files will\n"
    " change to enable fetching from remote locations, via git, etc. but for now we\n"
    " just support standard library artifacts, a single blueprint file, and a single\n"
    " expectations directory. Furthermore note that we will ignore non-json files within\n"
    " an org's team's expectation directory and incorrectly placed json files will also\n"
    " be ignored.\n"
).
-spec link(binary(), binary()) -> {ok,
        list(caffeine_lang@middle_end@semantic_analyzer:intermediate_representation())} |
    {error, caffeine_lang@common@errors:compilation_error()}.
link(Blueprint_file_path, Expectations_directory) ->
    caffeine_lang@common@helpers:result_try(
        caffeine_lang@parser@artifacts:parse_standard_library(),
        fun(Artifacts) ->
            caffeine_lang@common@helpers:result_try(
                caffeine_lang@parser@blueprints:parse_from_file(
                    Blueprint_file_path,
                    Artifacts
                ),
                fun(Blueprints) ->
                    caffeine_lang@common@helpers:result_try(
                        fetch_expectations(Expectations_directory, Blueprints),
                        fun(Ir) -> {ok, Ir} end
                    )
                end
            )
        end
    ).