caffeine_lang

-module(caffeine_lang@linker@ir_builder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/linker/ir_builder.gleam").
-export([reserved_labels_from_artifacts/1, build_all/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/linker/ir_builder.gleam", 27).
?DOC(false).
-spec reserved_labels_from_artifacts(
    list(caffeine_lang@linker@artifacts:artifact())
) -> gleam@set:set(binary()).
reserved_labels_from_artifacts(Artifacts) ->
    _pipe = Artifacts,
    _pipe@1 = gleam@list:flat_map(
        _pipe,
        fun(Artifact) -> maps:keys(erlang:element(4, Artifact)) end
    ),
    _pipe@2 = gleam@set:from_list(_pipe@1),
    gleam@set:delete(_pipe@2, <<"vendor"/utf8>>).

-file("src/caffeine_lang/linker/ir_builder.gleam", 103).
?DOC(
    " Resolves the vendor from an indexed Dict of ValueTuples at IR construction time.\n"
    " SLO artifacts require a vendor; dependency-only artifacts get None.\n"
).
-spec resolve_vendor_from_values(
    gleam@dict:dict(binary(), caffeine_lang@helpers:value_tuple()),
    list(caffeine_lang@linker@artifacts:artifact_type()),
    binary()
) -> {ok, gleam@option:option(caffeine_lang@analysis@vendor:vendor())} |
    {error, caffeine_lang@errors:compilation_error()}.
resolve_vendor_from_values(Index, Artifact_refs, Identifier) ->
    Has_slo = gleam@list:contains(Artifact_refs, s_l_o),
    gleam@bool:guard(
        not Has_slo,
        {ok, none},
        fun() ->
            Vendor_value = gleam_stdlib:map_get(Index, <<"vendor"/utf8>>),
            case Vendor_value of
                {error, nil} ->
                    {error,
                        caffeine_lang@errors:linker_vendor_resolution_error(
                            <<<<"expectation '"/utf8, Identifier/binary>>/binary,
                                "' - missing 'vendor' field"/utf8>>
                        )};

                {ok, Vt} ->
                    case caffeine_lang@value:extract_string(
                        erlang:element(4, Vt)
                    ) of
                        {error, _} ->
                            {error,
                                caffeine_lang@errors:linker_vendor_resolution_error(
                                    <<<<"expectation '"/utf8,
                                            Identifier/binary>>/binary,
                                        "' - 'vendor' field is not a string"/utf8>>
                                )};

                        {ok, Vendor_string} ->
                            case caffeine_lang@analysis@vendor:resolve_vendor(
                                Vendor_string
                            ) of
                                {ok, V} ->
                                    {ok, {some, V}};

                                {error, _} ->
                                    {error,
                                        caffeine_lang@errors:linker_vendor_resolution_error(
                                            <<<<<<<<"expectation '"/utf8,
                                                            Identifier/binary>>/binary,
                                                        "' - unknown vendor '"/utf8>>/binary,
                                                    Vendor_string/binary>>/binary,
                                                "'"/utf8>>
                                        )}
                            end
                    end
            end
        end
    ).

-file("src/caffeine_lang/linker/ir_builder.gleam", 154).
?DOC(" Build value tuples from provided inputs.\n").
-spec build_provided_value_tuples(
    gleam@dict:dict(binary(), caffeine_lang@value:value()),
    gleam@dict:dict(binary(), caffeine_lang@types:accepted_types())
) -> list(caffeine_lang@helpers:value_tuple()).
build_provided_value_tuples(Merged_inputs, Params) ->
    _pipe = Merged_inputs,
    _pipe@1 = maps:to_list(_pipe),
    gleam@list:filter_map(
        _pipe@1,
        fun(Pair) ->
            {Label, Val} = Pair,
            case gleam_stdlib:map_get(Params, Label) of
                {ok, Typ} ->
                    {ok, {value_tuple, Label, Typ, Val}};

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

-file("src/caffeine_lang/linker/ir_builder.gleam", 171).
?DOC(
    " Build value tuples for Optional/Defaulted params that weren't provided.\n"
    " These need to be in value_tuples so the templatizer can resolve them.\n"
).
-spec build_unprovided_optional_value_tuples(
    gleam@dict:dict(binary(), caffeine_lang@value:value()),
    gleam@dict:dict(binary(), caffeine_lang@types:accepted_types())
) -> list(caffeine_lang@helpers:value_tuple()).
build_unprovided_optional_value_tuples(Merged_inputs, Params) ->
    _pipe = Params,
    _pipe@1 = maps:to_list(_pipe),
    gleam@list:filter_map(
        _pipe@1,
        fun(Param) ->
            {Label, Typ} = Param,
            gleam@bool:guard(
                gleam@dict:has_key(Merged_inputs, Label),
                {error, nil},
                fun() ->
                    case caffeine_lang@types:is_optional_or_defaulted(Typ) of
                        true ->
                            {ok, {value_tuple, Label, Typ, nil_value}};

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

-file("src/caffeine_lang/linker/ir_builder.gleam", 144).
?DOC(
    " Build value tuples from merged inputs and params.\n"
    " Includes both provided inputs and unprovided Optional/Defaulted params.\n"
).
-spec build_value_tuples(
    gleam@dict:dict(binary(), caffeine_lang@value:value()),
    gleam@dict:dict(binary(), caffeine_lang@types:accepted_types())
) -> list(caffeine_lang@helpers:value_tuple()).
build_value_tuples(Merged_inputs, Params) ->
    Provided = build_provided_value_tuples(Merged_inputs, Params),
    Unprovided = build_unprovided_optional_value_tuples(Merged_inputs, Params),
    lists:append(Provided, Unprovided).

-file("src/caffeine_lang/linker/ir_builder.gleam", 219).
?DOC(
    " Resolves a value tuple to a list of strings for use as tags.\n"
    " Primitives and refinements produce a single-element list.\n"
    " Lists are exploded into multiple string values.\n"
    " Dicts and type alias refs are unsupported.\n"
    " Optional(None) produces an empty list (filtered out).\n"
    " Defaulted(None) produces the default value.\n"
).
-spec resolve_values_for_tag(
    caffeine_lang@types:accepted_types(),
    caffeine_lang@value:value()
) -> {ok, list(binary())} | {error, nil}.
resolve_values_for_tag(Typ, Val) ->
    case Typ of
        {primitive_type, _} ->
            {ok, [caffeine_lang@value:to_string(Val)]};

        {refinement_type, Refinement} ->
            case Refinement of
                {one_of, Inner, _} ->
                    resolve_values_for_tag(Inner, Val);

                {inclusive_range, Inner@1, _, _} ->
                    resolve_values_for_tag(Inner@1, Val)
            end;

        {collection_type, {list, Inner@2}} ->
            case Val of
                {list_value, Items} ->
                    _pipe = Items,
                    _pipe@2 = gleam@list:try_map(
                        _pipe,
                        fun(Item) ->
                            _pipe@1 = resolve_values_for_tag(Inner@2, Item),
                            gleam@result:map(
                                _pipe@1,
                                fun(Strings) -> Strings end
                            )
                        end
                    ),
                    gleam@result:map(_pipe@2, fun lists:append/1);

                _ ->
                    {error, nil}
            end;

        {collection_type, {dict, _, _}} ->
            {error, nil};

        {record_type, _} ->
            {error, nil};

        {modifier_type, {optional, Inner@3}} ->
            case Val of
                nil_value ->
                    {ok, []};

                _ ->
                    resolve_values_for_tag(Inner@3, Val)
            end;

        {modifier_type, {defaulted, Inner@4, Default}} ->
            case Val of
                nil_value ->
                    {ok, [Default]};

                _ ->
                    resolve_values_for_tag(Inner@4, Val)
            end
    end.

-file("src/caffeine_lang/linker/ir_builder.gleam", 194).
?DOC(
    " Extract misc metadata from value tuples.\n"
    " Filters out reserved labels (derived from artifact params) and unsupported types.\n"
    " Each key maps to a list of string values (primitives become single-element\n"
    " lists, collection lists are exploded, nulls are excluded).\n"
).
-spec extract_misc_metadata(
    list(caffeine_lang@helpers:value_tuple()),
    gleam@set:set(binary())
) -> gleam@dict:dict(binary(), list(binary())).
extract_misc_metadata(Value_tuples, Reserved_labels) ->
    _pipe = Value_tuples,
    _pipe@1 = gleam@list:filter_map(
        _pipe,
        fun(Value_tuple) ->
            gleam@bool:guard(
                gleam@set:contains(
                    Reserved_labels,
                    erlang:element(2, Value_tuple)
                ),
                {error, nil},
                fun() ->
                    case resolve_values_for_tag(
                        erlang:element(3, Value_tuple),
                        erlang:element(4, Value_tuple)
                    ) of
                        {ok, []} ->
                            {error, nil};

                        {ok, Values} ->
                            {ok, {erlang:element(2, Value_tuple), Values}};

                        {error, _} ->
                            {error, nil}
                    end
                end
            )
        end
    ),
    maps:from_list(_pipe@1).

-file("src/caffeine_lang/linker/ir_builder.gleam", 291).
?DOC(" Extract SLO-specific fields from an indexed Dict of ValueTuples.\n").
-spec build_slo_fields(
    gleam@dict:dict(binary(), caffeine_lang@helpers:value_tuple())
) -> caffeine_lang@linker@ir:slo_fields().
build_slo_fields(Index) ->
    Threshold = caffeine_lang@helpers:extract_threshold_indexed(Index),
    Indicators = caffeine_lang@helpers:extract_indicators_indexed(Index),
    Window_in_days = caffeine_lang@helpers:extract_window_in_days_indexed(Index),
    Evaluation = begin
        _pipe = caffeine_lang@helpers:extract_value_indexed(
            Index,
            <<"evaluation"/utf8>>,
            fun caffeine_lang@value:extract_string/1
        ),
        gleam@option:from_result(_pipe)
    end,
    Tags = caffeine_lang@helpers:extract_tags_indexed(Index),
    Runbook = begin
        _pipe@1 = caffeine_lang@helpers:extract_value_indexed(
            Index,
            <<"runbook"/utf8>>,
            fun(V) -> case V of
                    nil_value ->
                        {ok, none};

                    {string_value, S} ->
                        {ok, {some, S}};

                    _ ->
                        {error, nil}
                end end
        ),
        gleam@result:unwrap(_pipe@1, none)
    end,
    {slo_fields,
        Threshold,
        Indicators,
        Window_in_days,
        Evaluation,
        Tags,
        Runbook}.

-file("src/caffeine_lang/linker/ir_builder.gleam", 322).
?DOC(" Extract dependency-specific fields from an indexed Dict of ValueTuples.\n").
-spec build_dependency_fields(
    gleam@dict:dict(binary(), caffeine_lang@helpers:value_tuple())
) -> caffeine_lang@linker@ir:dependency_fields().
build_dependency_fields(Index) ->
    {dependency_fields,
        caffeine_lang@helpers:extract_relations_indexed(Index),
        caffeine_lang@helpers:extract_tags_indexed(Index)}.

-file("src/caffeine_lang/linker/ir_builder.gleam", 261).
?DOC(" Build structured artifact data from artifact refs and an indexed Dict of ValueTuples.\n").
-spec build_artifact_data(
    list(caffeine_lang@linker@artifacts:artifact_type()),
    gleam@dict:dict(binary(), caffeine_lang@helpers:value_tuple())
) -> caffeine_lang@linker@ir:artifact_data().
build_artifact_data(Artifact_refs, Index) ->
    Fields = begin
        _pipe = Artifact_refs,
        _pipe@1 = gleam@list:map(_pipe, fun(Ref) -> case Ref of
                    s_l_o ->
                        {s_l_o, {slo_artifact_fields, build_slo_fields(Index)}};

                    dependency_relations ->
                        {dependency_relations,
                            {dependency_artifact_fields,
                                build_dependency_fields(Index)}}
                end end),
        maps:from_list(_pipe@1)
    end,
    Fields@1 = case gleam@dict:is_empty(Fields) of
        true ->
            maps:from_list(
                [{s_l_o, {slo_artifact_fields, build_slo_fields(Index)}}]
            );

        false ->
            Fields
    end,
    {artifact_data, Fields@1}.

-file("src/caffeine_lang/linker/ir_builder.gleam", 52).
?DOC(" Build intermediate representations from validated expectations for a single file.\n").
-spec build(
    list({caffeine_lang@linker@expectations:expectation(),
        caffeine_lang@linker@blueprints:blueprint(caffeine_lang@linker@blueprints:blueprint_validated())}),
    binary(),
    gleam@set:set(binary())
) -> {ok,
        list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:linked()))} |
    {error, caffeine_lang@errors:compilation_error()}.
build(Expectations_blueprint_collection, File_path, Reserved_labels) ->
    {Org, Team, Service} = caffeine_lang@helpers:extract_path_prefix(File_path),
    _pipe = Expectations_blueprint_collection,
    gleam@list:try_map(
        _pipe,
        fun(Expectation_and_blueprint_pair) ->
            {Expectation, Blueprint} = Expectation_and_blueprint_pair,
            Merged_inputs = maps:merge(
                erlang:element(5, Blueprint),
                erlang:element(4, Expectation)
            ),
            Value_tuples = build_value_tuples(
                Merged_inputs,
                erlang:element(4, Blueprint)
            ),
            Index = caffeine_lang@helpers:index_value_tuples(Value_tuples),
            Misc_metadata = extract_misc_metadata(Value_tuples, Reserved_labels),
            Unique_name = <<<<<<<<Org/binary, "_"/utf8>>/binary,
                        Service/binary>>/binary,
                    "_"/utf8>>/binary,
                (erlang:element(2, Expectation))/binary>>,
            Artifact_data = build_artifact_data(
                erlang:element(3, Blueprint),
                Index
            ),
            gleam@result:'try'(
                resolve_vendor_from_values(
                    Index,
                    erlang:element(3, Blueprint),
                    <<<<<<<<<<<<Org/binary, "."/utf8>>/binary, Team/binary>>/binary,
                                    "."/utf8>>/binary,
                                Service/binary>>/binary,
                            "."/utf8>>/binary,
                        (erlang:element(2, Expectation))/binary>>
                ),
                fun(Resolved_vendor) ->
                    {ok,
                        {intermediate_representation,
                            {intermediate_representation_meta_data,
                                {expectation_label,
                                    erlang:element(2, Expectation)},
                                {org_name, Org},
                                {service_name, Service},
                                {blueprint_name, erlang:element(2, Blueprint)},
                                {team_name, Team},
                                Misc_metadata},
                            Unique_name,
                            erlang:element(3, Blueprint),
                            Value_tuples,
                            Artifact_data,
                            Resolved_vendor}}
                end
            )
        end
    ).

-file("src/caffeine_lang/linker/ir_builder.gleam", 36).
?DOC(false).
-spec build_all(
    list({list({caffeine_lang@linker@expectations:expectation(),
            caffeine_lang@linker@blueprints:blueprint(caffeine_lang@linker@blueprints:blueprint_validated())}),
        binary()}),
    gleam@set:set(binary())
) -> {ok,
        list(caffeine_lang@linker@ir:intermediate_representation(caffeine_lang@linker@ir:linked()))} |
    {error, caffeine_lang@errors:compilation_error()}.
build_all(Expectations_with_paths, Reserved_labels) ->
    _pipe = Expectations_with_paths,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Pair) ->
            {Expectations_blueprint_collection, File_path} = Pair,
            build(Expectations_blueprint_collection, File_path, Reserved_labels)
        end
    ),
    _pipe@2 = caffeine_lang@errors:from_results(_pipe@1),
    gleam@result:map(_pipe@2, fun lists:append/1).