-module(caffeine_lang@helpers).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/helpers.gleam").
-export([map_reference_to_referrer_over_collection/4, extract_path_prefix/1, extract_value/3, extract_threshold/1, extract_relations/1, extract_indicators/1, extract_tags/1, build_system_tag_pairs/7, extract_window_in_days/1]).
-export_type([value_tuple/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 value_tuple() :: {value_tuple,
        binary(),
        caffeine_lang@types:accepted_types(),
        caffeine_lang@value:value()}.

-file("src/caffeine_lang/helpers.gleam", 24).
?DOC(false).
-spec map_reference_to_referrer_over_collection(
    list(GVG),
    list(GVI),
    fun((GVG) -> binary()),
    fun((GVI) -> binary())
) -> list({GVI, GVG}).
map_reference_to_referrer_over_collection(
    References,
    Referrers,
    Reference_name,
    Referrer_reference
) ->
    _pipe = Referrers,
    gleam@list:filter_map(_pipe, fun(Referrer) -> _pipe@1 = References,
            _pipe@4 = gleam@list:find(
                _pipe@1,
                fun(Reference) ->
                    begin
                        _pipe@2 = Reference,
                        Reference_name(_pipe@2)
                    end
                    =:= begin
                        _pipe@3 = Referrer,
                        Referrer_reference(_pipe@3)
                    end
                end
            ),
            gleam@result:map(
                _pipe@4,
                fun(Reference@1) -> {Referrer, Reference@1} end
            ) end).

-file("src/caffeine_lang/helpers.gleam", 43).
?DOC(false).
-spec extract_path_prefix(binary()) -> {binary(), binary(), binary()}.
extract_path_prefix(Path) ->
    case begin
        _pipe = Path,
        _pipe@1 = gleam@string:split(_pipe, <<"/"/utf8>>),
        _pipe@2 = lists:reverse(_pipe@1),
        _pipe@3 = gleam@list:take(_pipe@2, 3),
        _pipe@4 = lists:reverse(_pipe@3),
        gleam@list:map(
            _pipe@4,
            fun(Segment) ->
                case gleam_stdlib:string_ends_with(
                    Segment,
                    <<".caffeine"/utf8>>
                ) of
                    true ->
                        gleam@string:drop_end(Segment, 9);

                    false ->
                        case gleam_stdlib:string_ends_with(
                            Segment,
                            <<".json"/utf8>>
                        ) of
                            true ->
                                gleam@string:drop_end(Segment, 5);

                            false ->
                                Segment
                        end
                end
            end
        )
    end of
        [Org, Team, Service] ->
            {Org, Team, Service};

        _ ->
            {<<"unknown"/utf8>>, <<"unknown"/utf8>>, <<"unknown"/utf8>>}
    end.

-file("src/caffeine_lang/helpers.gleam", 74).
?DOC(false).
-spec extract_value(
    list(value_tuple()),
    binary(),
    fun((caffeine_lang@value:value()) -> {ok, GVM} | {error, nil})
) -> {ok, GVM} | {error, nil}.
extract_value(Values, Label, Extractor) ->
    _pipe = Values,
    _pipe@1 = gleam@list:find(
        _pipe,
        fun(Vt) -> erlang:element(2, Vt) =:= Label end
    ),
    gleam@result:'try'(
        _pipe@1,
        fun(Vt@1) -> Extractor(erlang:element(4, Vt@1)) end
    ).

-file("src/caffeine_lang/helpers.gleam", 87).
?DOC(false).
-spec extract_threshold(list(value_tuple())) -> float().
extract_threshold(Values) ->
    Threshold@1 = case extract_value(
        Values,
        <<"threshold"/utf8>>,
        fun caffeine_lang@value:extract_percentage/1
    ) of
        {ok, Threshold} -> Threshold;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"caffeine_lang/helpers"/utf8>>,
                        function => <<"extract_threshold"/utf8>>,
                        line => 88,
                        value => _assert_fail,
                        start => 2768,
                        'end' => 2859,
                        pattern_start => 2779,
                        pattern_end => 2792})
    end,
    Threshold@1.

-file("src/caffeine_lang/helpers.gleam", 96).
?DOC(false).
-spec extract_relations(list(value_tuple())) -> gleam@dict:dict(caffeine_lang@linker@artifacts:dependency_relation_type(), list(binary())).
extract_relations(Values) ->
    _pipe = Values,
    _pipe@1 = gleam@list:find(
        _pipe,
        fun(Vt) -> erlang:element(2, Vt) =:= <<"relations"/utf8>> end
    ),
    _pipe@9 = gleam@result:'try'(
        _pipe@1,
        fun(Vt@1) -> case erlang:element(4, Vt@1) of
                {dict_value, D} ->
                    _pipe@2 = D,
                    _pipe@3 = maps:to_list(_pipe@2),
                    _pipe@6 = gleam@list:try_map(
                        _pipe@3,
                        fun(Pair) -> case erlang:element(2, Pair) of
                                {list_value, Items} ->
                                    _pipe@4 = Items,
                                    _pipe@5 = gleam@list:try_map(
                                        _pipe@4,
                                        fun caffeine_lang@value:extract_string/1
                                    ),
                                    gleam@result:map(
                                        _pipe@5,
                                        fun(Strings) ->
                                            {erlang:element(1, Pair), Strings}
                                        end
                                    );

                                _ ->
                                    {error, nil}
                            end end
                    ),
                    gleam@result:map(_pipe@6, fun(Pairs) -> _pipe@7 = Pairs,
                            _pipe@8 = gleam@list:filter_map(
                                _pipe@7,
                                fun(Pair@1) ->
                                    case caffeine_lang@linker@artifacts:parse_relation_type(
                                        erlang:element(1, Pair@1)
                                    ) of
                                        {ok, Rt} ->
                                            {ok,
                                                {Rt, erlang:element(2, Pair@1)}};

                                        {error, nil} ->
                                            {error, nil}
                                    end
                                end
                            ),
                            maps:from_list(_pipe@8) end);

                _ ->
                    {error, nil}
            end end
    ),
    gleam@result:unwrap(_pipe@9, maps:new()).

-file("src/caffeine_lang/helpers.gleam", 144).
?DOC(false).
-spec extract_indicators(list(value_tuple())) -> gleam@dict:dict(binary(), binary()).
extract_indicators(Values) ->
    _pipe = Values,
    _pipe@1 = gleam@list:find(
        _pipe,
        fun(Vt) -> erlang:element(2, Vt) =:= <<"indicators"/utf8>> end
    ),
    _pipe@2 = gleam@result:'try'(
        _pipe@1,
        fun(Vt@1) ->
            caffeine_lang@value:extract_string_dict(erlang:element(4, Vt@1))
        end
    ),
    gleam@result:unwrap(_pipe@2, maps:new()).

-file("src/caffeine_lang/helpers.gleam", 153).
?DOC(false).
-spec extract_tags(list(value_tuple())) -> list({binary(), binary()}).
extract_tags(Values) ->
    _pipe = Values,
    _pipe@1 = gleam@list:find(
        _pipe,
        fun(Vt) -> erlang:element(2, Vt) =:= <<"tags"/utf8>> end
    ),
    _pipe@2 = gleam@result:'try'(
        _pipe@1,
        fun(Vt@1) -> case erlang:element(4, Vt@1) of
                nil_value ->
                    {ok, maps:new()};

                {dict_value, _} ->
                    caffeine_lang@value:extract_string_dict(
                        erlang:element(4, Vt@1)
                    );

                _ ->
                    {error, nil}
            end end
    ),
    _pipe@3 = gleam@result:unwrap(_pipe@2, maps:new()),
    _pipe@4 = maps:to_list(_pipe@3),
    gleam@list:sort(
        _pipe@4,
        fun(A, B) ->
            gleam@string:compare(erlang:element(1, A), erlang:element(1, B))
        end
    ).

-file("src/caffeine_lang/helpers.gleam", 170).
?DOC(
    " Build system tag key-value pairs from IR metadata fields and artifact refs.\n"
    " Returns a sorted, deterministic list of tag pairs shared across all generators.\n"
).
-spec build_system_tag_pairs(
    caffeine_lang@identifiers:org_name(),
    caffeine_lang@identifiers:team_name(),
    caffeine_lang@identifiers:service_name(),
    caffeine_lang@identifiers:blueprint_name(),
    caffeine_lang@identifiers:expectation_label(),
    list(caffeine_lang@linker@artifacts:artifact_type()),
    gleam@dict:dict(binary(), list(binary()))
) -> list({binary(), binary()}).
build_system_tag_pairs(
    Org_name,
    Team_name,
    Service_name,
    Blueprint_name,
    Friendly_label,
    Artifact_refs,
    Misc
) ->
    _pipe = [{<<"managed_by"/utf8>>, <<"caffeine"/utf8>>},
        {<<"caffeine_version"/utf8>>, <<"4.6.4"/utf8>>},
        {<<"org"/utf8>>, erlang:element(2, Org_name)},
        {<<"team"/utf8>>, erlang:element(2, Team_name)},
        {<<"service"/utf8>>, erlang:element(2, Service_name)},
        {<<"blueprint"/utf8>>, erlang:element(2, Blueprint_name)},
        {<<"expectation"/utf8>>, erlang:element(2, Friendly_label)}],
    _pipe@2 = lists:append(
        _pipe,
        begin
            _pipe@1 = Artifact_refs,
            gleam@list:map(
                _pipe@1,
                fun(Ref) ->
                    {<<"artifact"/utf8>>,
                        caffeine_lang@linker@artifacts:artifact_type_to_string(
                            Ref
                        )}
                end
            )
        end
    ),
    lists:append(
        _pipe@2,
        begin
            _pipe@3 = Misc,
            _pipe@4 = maps:to_list(_pipe@3),
            _pipe@5 = gleam@list:sort(
                _pipe@4,
                fun(A, B) ->
                    gleam@string:compare(
                        erlang:element(1, A),
                        erlang:element(1, B)
                    )
                end
            ),
            gleam@list:flat_map(
                _pipe@5,
                fun(Pair) ->
                    {Key, Values} = Pair,
                    _pipe@6 = Values,
                    _pipe@7 = gleam@list:sort(
                        _pipe@6,
                        fun gleam@string:compare/2
                    ),
                    gleam@list:map(_pipe@7, fun(Value) -> {Key, Value} end)
                end
            )
        end
    ).

-file("src/caffeine_lang/helpers.gleam", 137).
?DOC(false).
-spec extract_window_in_days(list(value_tuple())) -> integer().
extract_window_in_days(Values) ->
    _pipe = extract_value(
        Values,
        <<"window_in_days"/utf8>>,
        fun caffeine_lang@value:extract_int/1
    ),
    gleam@result:unwrap(_pipe, 30).