-module(caffeine_lang@analysis@semantic_analyzer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/analysis/semantic_analyzer.gleam").
-export([resolve_indicators/1, resolve_intermediate_representations/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/caffeine_lang/analysis/semantic_analyzer.gleam", 39).
?DOC(false).
-spec resolve_indicators(caffeine_lang@linker@ir:intermediate_representation()) -> {ok,
        caffeine_lang@linker@ir:intermediate_representation()} |
    {error, caffeine_lang@errors:compilation_error()}.
resolve_indicators(Ir) ->
    case erlang:element(7, Ir) of
        {some, datadog} ->
            gleam@result:'try'(
                begin
                    _pipe = erlang:element(5, Ir),
                    _pipe@1 = gleam@list:find(
                        _pipe,
                        fun(Vt) ->
                            erlang:element(2, Vt) =:= <<"indicators"/utf8>>
                        end
                    ),
                    gleam@result:replace_error(
                        _pipe@1,
                        {semantic_analysis_template_resolution_error,
                            <<<<"expectation '"/utf8,
                                    (caffeine_lang@linker@ir:ir_to_identifier(
                                        Ir
                                    ))/binary>>/binary,
                                "' - missing 'indicators' field in IR"/utf8>>,
                            caffeine_lang@errors:empty_context()}
                    )
                end,
                fun(Indicators_value_tuple) ->
                    gleam@result:'try'(
                        begin
                            _pipe@2 = caffeine_lang@value:extract_string_dict(
                                erlang:element(4, Indicators_value_tuple)
                            ),
                            gleam@result:map_error(
                                _pipe@2,
                                fun(_) ->
                                    {semantic_analysis_template_resolution_error,
                                        <<<<"expectation '"/utf8,
                                                (caffeine_lang@linker@ir:ir_to_identifier(
                                                    Ir
                                                ))/binary>>/binary,
                                            "' - failed to decode indicators"/utf8>>,
                                        caffeine_lang@errors:empty_context()}
                                end
                            )
                        end,
                        fun(Indicators_dict) ->
                            Identifier = caffeine_lang@linker@ir:ir_to_identifier(
                                Ir
                            ),
                            gleam@result:'try'(
                                begin
                                    _pipe@3 = Indicators_dict,
                                    _pipe@4 = maps:to_list(_pipe@3),
                                    gleam@list:try_map(
                                        _pipe@4,
                                        fun(Pair) ->
                                            {Key, Indicator} = Pair,
                                            gleam@result:map(
                                                caffeine_lang@analysis@templatizer:parse_and_resolve_query_template(
                                                    Indicator,
                                                    erlang:element(5, Ir),
                                                    Identifier
                                                ),
                                                fun(Resolved) ->
                                                    {Key, Resolved}
                                                end
                                            )
                                        end
                                    )
                                end,
                                fun(Resolved_indicators) ->
                                    Resolved_indicators_value = begin
                                        _pipe@5 = Resolved_indicators,
                                        _pipe@6 = gleam@list:map(
                                            _pipe@5,
                                            fun(Pair@1) ->
                                                {erlang:element(1, Pair@1),
                                                    {string_value,
                                                        erlang:element(
                                                            2,
                                                            Pair@1
                                                        )}}
                                            end
                                        ),
                                        _pipe@7 = maps:from_list(_pipe@6),
                                        {dict_value, _pipe@7}
                                    end,
                                    New_indicators_value_tuple = {value_tuple,
                                        <<"indicators"/utf8>>,
                                        {collection_type,
                                            {dict,
                                                {primitive_type, string},
                                                {primitive_type, string}}},
                                        Resolved_indicators_value},
                                    Evaluation_tuple_result = begin
                                        _pipe@8 = erlang:element(5, Ir),
                                        gleam@list:find(
                                            _pipe@8,
                                            fun(Vt@1) ->
                                                erlang:element(2, Vt@1) =:= <<"evaluation"/utf8>>
                                            end
                                        )
                                    end,
                                    gleam@result:'try'(
                                        case Evaluation_tuple_result of
                                            {error, _} ->
                                                {ok, none};

                                            {ok, Evaluation_tuple} ->
                                                gleam@result:'try'(
                                                    begin
                                                        _pipe@9 = caffeine_lang@value:extract_string(
                                                            erlang:element(
                                                                4,
                                                                Evaluation_tuple
                                                            )
                                                        ),
                                                        gleam@result:map_error(
                                                            _pipe@9,
                                                            fun(_) ->
                                                                {semantic_analysis_template_resolution_error,
                                                                    <<<<"expectation '"/utf8,
                                                                            (caffeine_lang@linker@ir:ir_to_identifier(
                                                                                Ir
                                                                            ))/binary>>/binary,
                                                                        "' - failed to decode 'evaluation' field as string"/utf8>>,
                                                                    caffeine_lang@errors:empty_context(
                                                                        
                                                                    )}
                                                            end
                                                        )
                                                    end,
                                                    fun(Evaluation_string) ->
                                                        _pipe@10 = caffeine_lang@analysis@templatizer:parse_and_resolve_query_template(
                                                            Evaluation_string,
                                                            erlang:element(
                                                                5,
                                                                Ir
                                                            ),
                                                            Identifier
                                                        ),
                                                        gleam@result:map(
                                                            _pipe@10,
                                                            fun(
                                                                Resolved_evaluation
                                                            ) ->
                                                                {some,
                                                                    {value_tuple,
                                                                        <<"evaluation"/utf8>>,
                                                                        {primitive_type,
                                                                            string},
                                                                        {string_value,
                                                                            Resolved_evaluation}}}
                                                            end
                                                        )
                                                    end
                                                )
                                        end,
                                        fun(Resolved_evaluation_tuple) ->
                                            New_values = begin
                                                _pipe@11 = erlang:element(5, Ir),
                                                gleam@list:map(
                                                    _pipe@11,
                                                    fun(Vt@2) ->
                                                        case erlang:element(
                                                            2,
                                                            Vt@2
                                                        ) of
                                                            <<"indicators"/utf8>> ->
                                                                New_indicators_value_tuple;

                                                            <<"evaluation"/utf8>> ->
                                                                case Resolved_evaluation_tuple of
                                                                    {some,
                                                                        New_evaluation} ->
                                                                        New_evaluation;

                                                                    none ->
                                                                        Vt@2
                                                                end;

                                                            _ ->
                                                                Vt@2
                                                        end
                                                    end
                                                )
                                            end,
                                            Resolved_indicators_dict = begin
                                                _pipe@12 = Resolved_indicators,
                                                maps:from_list(_pipe@12)
                                            end,
                                            Resolved_eval = case Resolved_evaluation_tuple of
                                                {some, Vt@3} ->
                                                    _pipe@13 = caffeine_lang@value:extract_string(
                                                        erlang:element(4, Vt@3)
                                                    ),
                                                    gleam@option:from_result(
                                                        _pipe@13
                                                    );

                                                none ->
                                                    _pipe@14 = caffeine_lang@linker@ir:get_slo_fields(
                                                        erlang:element(6, Ir)
                                                    ),
                                                    _pipe@15 = gleam@option:map(
                                                        _pipe@14,
                                                        fun(Slo) ->
                                                            erlang:element(
                                                                5,
                                                                Slo
                                                            )
                                                        end
                                                    ),
                                                    gleam@option:unwrap(
                                                        _pipe@15,
                                                        none
                                                    )
                                            end,
                                            New_artifact_data = caffeine_lang@linker@ir:update_slo_fields(
                                                erlang:element(6, Ir),
                                                fun(Slo@1) ->
                                                    {slo_fields,
                                                        erlang:element(2, Slo@1),
                                                        Resolved_indicators_dict,
                                                        erlang:element(4, Slo@1),
                                                        Resolved_eval,
                                                        erlang:element(6, Slo@1),
                                                        erlang:element(7, Slo@1)}
                                                end
                                            ),
                                            {ok,
                                                {intermediate_representation,
                                                    erlang:element(2, Ir),
                                                    erlang:element(3, Ir),
                                                    erlang:element(4, Ir),
                                                    New_values,
                                                    New_artifact_data,
                                                    erlang:element(7, Ir)}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        {some, honeycomb} ->
            {ok, Ir};

        {some, dynatrace} ->
            {ok, Ir};

        {some, new_relic} ->
            {ok, Ir};

        none ->
            {error,
                {semantic_analysis_template_resolution_error,
                    <<<<"expectation '"/utf8,
                            (caffeine_lang@linker@ir:ir_to_identifier(Ir))/binary>>/binary,
                        "' - no vendor resolved"/utf8>>,
                    caffeine_lang@errors:empty_context()}}
    end.

-file("src/caffeine_lang/analysis/semantic_analyzer.gleam", 23).
?DOC(false).
-spec resolve_intermediate_representations(
    list(caffeine_lang@linker@ir:intermediate_representation())
) -> {ok, list(caffeine_lang@linker@ir:intermediate_representation())} |
    {error, caffeine_lang@errors:compilation_error()}.
resolve_intermediate_representations(Irs) ->
    _pipe = Irs,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Ir) ->
            gleam@bool:guard(
                not gleam@list:contains(erlang:element(4, Ir), s_l_o),
                {ok, Ir},
                fun() -> resolve_indicators(Ir) end
            )
        end
    ),
    caffeine_lang@errors:from_results(_pipe@1).