-module(caffeine_lang@compiler).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/compiler.gleam").
-export([resolve_indicators/1, compile/2, compile_from_strings/4]).
-export_type([compilation_output/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 compilation_output() :: {compilation_output,
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(gleam@dict:dict(binary(), binary())),
        list(binary())}.

-file("src/caffeine_lang/compiler.gleam", 117).
-spec run_code_generation(
    list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:resolved()))
) -> {ok, compilation_output()} |
    {error, caffeine_lang@errors:compilation_error()}.
run_code_generation(Resolved_irs) ->
    Measured_irs = begin
        _pipe = Resolved_irs,
        _pipe@1 = gleam@list:filter(
            _pipe,
            fun(Ir) -> gleam@option:is_some(erlang:element(6, Ir)) end
        ),
        gleam@list:sort(
            _pipe@1,
            fun(A, B) ->
                gleam@string:compare(erlang:element(3, A), erlang:element(3, B))
            end
        )
    end,
    Platform = caffeine_lang@codegen@platforms:datadog_platform(),
    gleam@result:'try'(
        (erlang:element(8, Platform))(Measured_irs),
        fun(_use0) ->
            {All_resources, All_warnings} = _use0,
            Terraform_settings = caffeine_lang@codegen@platforms:terraform_settings(
                Platform
            ),
            Boilerplate_config = {config,
                {some, Terraform_settings},
                [caffeine_lang@codegen@platforms:provider(Platform)],
                [],
                [],
                erlang:element(7, Platform),
                [],
                [],
                []},
            Boilerplate = terra_madre@render:render_config(Boilerplate_config),
            Metadata_by_name = begin
                _pipe@2 = Resolved_irs,
                _pipe@3 = gleam@list:flat_map(
                    _pipe@2,
                    fun(Ir@1) ->
                        Base = terra_madre@common:sanitize_terraform_identifier(
                            erlang:element(3, Ir@1)
                        ),
                        [{Base, erlang:element(2, Ir@1)},
                            {<<Base/binary, "_sli"/utf8>>,
                                erlang:element(2, Ir@1)}]
                    end
                ),
                maps:from_list(_pipe@3)
            end,
            Resource_sections = begin
                _pipe@4 = All_resources,
                gleam@list:map(
                    _pipe@4,
                    fun(Resource) ->
                        Rendered = caffeine_lang@codegen@generator_utils:render_resource_to_string(
                            Resource
                        ),
                        case gleam_stdlib:map_get(
                            Metadata_by_name,
                            erlang:element(3, Resource)
                        ) of
                            {ok, Metadata} ->
                                <<<<(caffeine_lang@codegen@generator_utils:build_source_comment(
                                            Metadata
                                        ))/binary,
                                        "\n"/utf8>>/binary,
                                    Rendered/binary>>;

                            {error, _} ->
                                Rendered
                        end
                    end
                )
            end,
            Terraform_output = case Resource_sections of
                [] ->
                    Boilerplate;

                Sections ->
                    Trimmed_boilerplate = gleam@string:drop_end(Boilerplate, 1),
                    <<<<<<Trimmed_boilerplate/binary, "\n\n"/utf8>>/binary,
                            (gleam@string:join(Sections, <<"\n\n"/utf8>>))/binary>>/binary,
                        "\n"/utf8>>
            end,
            Has_deps = begin
                _pipe@5 = Resolved_irs,
                gleam@list:any(
                    _pipe@5,
                    fun(Ir@2) ->
                        gleam@option:is_some(
                            erlang:element(8, erlang:element(5, Ir@2))
                        )
                    end
                )
            end,
            Graph = case Has_deps of
                true ->
                    {some,
                        caffeine_lang@codegen@dependency_graph:generate(
                            Resolved_irs
                        )};

                false ->
                    none
            end,
            Relay_signals = caffeine_lang@codegen@relay:generate(Resolved_irs),
            {Relay_workflow_artifact, Relay_bundle_artifact} = case Relay_signals of
                none ->
                    {none, none};

                {some, _} ->
                    {{some, caffeine_lang@codegen@relay_workflow:generate()},
                        caffeine_lang@codegen@relay_bundle:generate()}
            end,
            {ok,
                {compilation_output,
                    Terraform_output,
                    Graph,
                    Relay_signals,
                    Relay_workflow_artifact,
                    Relay_bundle_artifact,
                    All_warnings}}
        end
    ).

-file("src/caffeine_lang/compiler.gleam", 108).
?DOC(false).
-spec resolve_indicators(
    caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:deps_validated())
) -> {ok,
        caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:resolved())} |
    {error, caffeine_lang@errors:compilation_error()}.
resolve_indicators(Ir) ->
    case erlang:element(6, Ir) of
        {some, datadog} ->
            caffeine_lang@codegen@datadog:resolve_indicators(Ir);

        none ->
            {ok, caffeine_lang@linker@ir:promote(Ir)}
    end.

-file("src/caffeine_lang/compiler.gleam", 94).
-spec run_semantic_analysis(
    list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:linked()))
) -> {ok,
        list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:resolved()))} |
    {error, caffeine_lang@errors:compilation_error()}.
run_semantic_analysis(Irs) ->
    gleam@result:'try'(
        caffeine_lang@analysis@dependency_validator:validate_dependency_relations(
            Irs
        ),
        fun(Validated_irs) -> _pipe = Validated_irs,
            _pipe@1 = gleam@list:map(_pipe, fun resolve_indicators/1),
            caffeine_lang@errors:from_results(_pipe@1) end
    ).

-file("src/caffeine_lang/compiler.gleam", 86).
-spec run_parse_and_link(
    list(caffeine_lang@source_file:vendor_measurement_source()),
    list(caffeine_lang@source_file:source_file(caffeine_lang@source_file:expectation_source()))
) -> {ok,
        list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:linked()))} |
    {error, caffeine_lang@errors:compilation_error()}.
run_parse_and_link(Measurements, Expectations) ->
    Slo_params = caffeine_lang@standard_library@artifacts:slo_params(),
    caffeine_lang@linker@linker:link(Measurements, Expectations, Slo_params).

-file("src/caffeine_lang/compiler.gleam", 56).
?DOC(
    " Compiles measurement sources and expectation sources into Terraform configuration.\n"
    " Pure function — all file reading happens before this function is called.\n"
).
-spec compile(
    list(caffeine_lang@source_file:vendor_measurement_source()),
    list(caffeine_lang@source_file:source_file(caffeine_lang@source_file:expectation_source()))
) -> {ok, compilation_output()} |
    {error, caffeine_lang@errors:compilation_error()}.
compile(Measurements, Expectations) ->
    gleam@result:'try'(
        run_parse_and_link(Measurements, Expectations),
        fun(Irs) ->
            gleam@result:'try'(
                run_semantic_analysis(Irs),
                fun(Resolved_irs) -> run_code_generation(Resolved_irs) end
            )
        end
    ).

-file("src/caffeine_lang/compiler.gleam", 216).
-spec parse_from_strings(binary(), binary(), binary(), binary()) -> {ok,
        list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:linked()))} |
    {error, caffeine_lang@errors:compilation_error()}.
parse_from_strings(
    Measurements_source,
    Expectations_source,
    Expectations_path,
    Vendor_string
) ->
    Slo_params = caffeine_lang@standard_library@artifacts:slo_params(),
    Reserved_labels = caffeine_lang@linker@ir_builder:reserved_labels(
        Slo_params
    ),
    gleam@result:'try'(
        begin
            _pipe = caffeine_lang@analysis@vendor:resolve_vendor(Vendor_string),
            gleam@result:replace_error(
                _pipe,
                caffeine_lang@errors:linker_vendor_resolution_error(
                    <<<<"unknown vendor '"/utf8, Vendor_string/binary>>/binary,
                        "'"/utf8>>
                )
            )
        end,
        fun(Resolved_vendor) ->
            gleam@result:'try'(
                caffeine_lang@frontend@pipeline:compile_measurements(
                    {source_file,
                        <<"browser/measurements.caffeine"/utf8>>,
                        Measurements_source}
                ),
                fun(Raw_measurements) ->
                    gleam@result:'try'(
                        caffeine_lang@frontend@pipeline:compile_expects(
                            {source_file,
                                <<"browser/expectations.caffeine"/utf8>>,
                                Expectations_source}
                        ),
                        fun(Raw_expectations) ->
                            gleam@result:'try'(
                                caffeine_lang@linker@measurements:validate_measurements(
                                    Raw_measurements,
                                    Slo_params
                                ),
                                fun(Validated_measurements) ->
                                    Vendor_lookup = begin
                                        _pipe@1 = Raw_measurements,
                                        _pipe@2 = gleam@list:map(
                                            _pipe@1,
                                            fun(Bp) ->
                                                {erlang:element(2, Bp),
                                                    Resolved_vendor}
                                            end
                                        ),
                                        maps:from_list(_pipe@2)
                                    end,
                                    gleam@result:'try'(
                                        caffeine_lang@linker@expectations:validate_expectations(
                                            Raw_expectations,
                                            Validated_measurements,
                                            Slo_params,
                                            Expectations_path
                                        ),
                                        fun(Expectations_measurement_collection) ->
                                            caffeine_lang@linker@ir_builder:build_all(
                                                [{Expectations_measurement_collection,
                                                        Expectations_path}],
                                                Reserved_labels,
                                                Vendor_lookup,
                                                Slo_params
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/caffeine_lang/compiler.gleam", 68).
?DOC(
    " Compiles from source strings directly (no file I/O).\n"
    " Used for browser-based compilation. The vendor parameter specifies\n"
    " which vendor the measurements belong to.\n"
).
-spec compile_from_strings(binary(), binary(), binary(), binary()) -> {ok,
        compilation_output()} |
    {error, caffeine_lang@errors:compilation_error()}.
compile_from_strings(
    Measurements_source,
    Expectations_source,
    Expectations_path,
    Vendor_string
) ->
    gleam@result:'try'(
        parse_from_strings(
            Measurements_source,
            Expectations_source,
            Expectations_path,
            Vendor_string
        ),
        fun(Irs) ->
            gleam@result:'try'(
                run_semantic_analysis(Irs),
                fun(Resolved_irs) -> run_code_generation(Resolved_irs) end
            )
        end
    ).