-module(caffeine_lang@generator@datadog).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/generator/datadog.gleam").
-export([terraform_settings/0, provider/0, variables/0, window_to_timeframe/1, ir_to_terraform_resource/1, generate_terraform/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/generator/datadog.gleam", 45).
?DOC(false).
-spec terraform_settings() -> terra_madre@terraform:terraform_settings().
terraform_settings() ->
    {terraform_settings,
        none,
        maps:from_list(
            [{<<"datadog"/utf8>>,
                    {provider_requirement,
                        <<"DataDog/datadog"/utf8>>,
                        {some, <<"~> 3.0"/utf8>>}}}]
        ),
        none,
        none}.

-file("src/caffeine_lang/generator/datadog.gleam", 61).
?DOC(false).
-spec provider() -> terra_madre@terraform:provider().
provider() ->
    {provider,
        <<"datadog"/utf8>>,
        none,
        maps:from_list(
            [{<<"api_key"/utf8>>,
                    terra_madre@hcl:ref(<<"var.datadog_api_key"/utf8>>)},
                {<<"app_key"/utf8>>,
                    terra_madre@hcl:ref(<<"var.datadog_app_key"/utf8>>)}]
        ),
        []}.

-file("src/caffeine_lang/generator/datadog.gleam", 75).
?DOC(false).
-spec variables() -> list(terra_madre@terraform:variable()).
variables() ->
    [{variable,
            <<"datadog_api_key"/utf8>>,
            {some, {identifier, <<"string"/utf8>>}},
            none,
            {some, <<"Datadog API key"/utf8>>},
            {some, true},
            none,
            []},
        {variable,
            <<"datadog_app_key"/utf8>>,
            {some, {identifier, <<"string"/utf8>>}},
            none,
            {some, <<"Datadog Application key"/utf8>>},
            {some, true},
            none,
            []}].

-file("src/caffeine_lang/generator/datadog.gleam", 193).
?DOC(false).
-spec window_to_timeframe(integer()) -> {ok, binary()} |
    {error, caffeine_lang@common@errors:compilation_error()}.
window_to_timeframe(Days) ->
    Days_string = erlang:integer_to_binary(Days),
    case Days of
        7 ->
            {ok, <<Days_string/binary, "d"/utf8>>};

        30 ->
            {ok, <<Days_string/binary, "d"/utf8>>};

        90 ->
            {ok, <<Days_string/binary, "d"/utf8>>};

        _ ->
            {error,
                {generator_datadog_terraform_resolution_error,
                    <<<<"Illegal window_in_days value: "/utf8,
                            Days_string/binary>>/binary,
                        ". Accepted values are 7, 30, or 90."/utf8>>}}
    end.

-file("src/caffeine_lang/generator/datadog.gleam", 101).
?DOC(false).
-spec ir_to_terraform_resource(
    caffeine_lang@middle_end@semantic_analyzer:intermediate_representation()
) -> {ok, terra_madre@terraform:resource()} |
    {error, caffeine_lang@common@errors:compilation_error()}.
ir_to_terraform_resource(Ir) ->
    Resource_name = terra_madre@common:sanitize_terraform_identifier(
        erlang:element(3, Ir)
    ),
    Threshold = begin
        _pipe = caffeine_lang@common@helpers:extract_value(
            erlang:element(5, Ir),
            <<"threshold"/utf8>>,
            {decoder, fun gleam@dynamic@decode:decode_float/1}
        ),
        gleam@result:unwrap(_pipe, 99.9)
    end,
    Window_in_days = begin
        _pipe@1 = caffeine_lang@common@helpers:extract_value(
            erlang:element(5, Ir),
            <<"window_in_days"/utf8>>,
            {decoder, fun gleam@dynamic@decode:decode_int/1}
        ),
        gleam@result:unwrap(_pipe@1, 30)
    end,
    Queries = begin
        _pipe@2 = caffeine_lang@common@helpers:extract_value(
            erlang:element(5, Ir),
            <<"queries"/utf8>>,
            gleam@dynamic@decode:dict(
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                {decoder, fun gleam@dynamic@decode:decode_string/1}
            )
        ),
        gleam@result:unwrap(_pipe@2, maps:new())
    end,
    Value_expr = begin
        _pipe@3 = caffeine_lang@common@helpers:extract_value(
            erlang:element(5, Ir),
            <<"value"/utf8>>,
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        gleam@result:unwrap(_pipe@3, <<"numerator / denominator"/utf8>>)
    end,
    gleam@result:'try'(
        begin
            _pipe@4 = caffeine_query_language@generator:resolve_slo_to_hcl(
                Value_expr,
                Queries
            ),
            gleam@result:map_error(
                _pipe@4,
                fun(Err) ->
                    {generator_slo_query_resolution_error,
                        <<<<<<"Failed to resolve SLO query for '"/utf8,
                                    (erlang:element(2, erlang:element(2, Ir)))/binary>>/binary,
                                "': "/utf8>>/binary,
                            Err/binary>>}
                end
            )
        end,
        fun(_use0) ->
            {resolved_slo_hcl, Slo_type, Slo_blocks} = _use0,
            Tags = {list_expr,
                begin
                    _pipe@5 = [{string_literal, <<"managed_by:caffeine"/utf8>>},
                        {string_literal,
                            <<"caffeine_version:"/utf8,
                                (<<"2.0.2"/utf8>>)/binary>>},
                        {string_literal,
                            <<"org:"/utf8,
                                (erlang:element(3, erlang:element(2, Ir)))/binary>>},
                        {string_literal,
                            <<"team:"/utf8,
                                (erlang:element(6, erlang:element(2, Ir)))/binary>>},
                        {string_literal,
                            <<"service:"/utf8,
                                (erlang:element(4, erlang:element(2, Ir)))/binary>>},
                        {string_literal,
                            <<"blueprint:"/utf8,
                                (erlang:element(5, erlang:element(2, Ir)))/binary>>},
                        {string_literal,
                            <<"expectation:"/utf8,
                                (erlang:element(2, erlang:element(2, Ir)))/binary>>},
                        {string_literal,
                            <<"artifact:"/utf8, (erlang:element(4, Ir))/binary>>}],
                    lists:append(
                        _pipe@5,
                        begin
                            _pipe@6 = erlang:element(7, erlang:element(2, Ir)),
                            _pipe@7 = maps:keys(_pipe@6),
                            _pipe@8 = gleam@list:sort(
                                _pipe@7,
                                fun gleam@string:compare/2
                            ),
                            gleam@list:map(
                                _pipe@8,
                                fun(Key) ->
                                    Value@1 = case begin
                                        _pipe@9 = erlang:element(
                                            7,
                                            erlang:element(2, Ir)
                                        ),
                                        gleam_stdlib:map_get(_pipe@9, Key)
                                    end of
                                        {ok, Value} -> Value;
                                        _assert_fail ->
                                            erlang:error(
                                                    #{gleam_error => let_assert,
                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                        file => <<?FILEPATH/utf8>>,
                                                        module => <<"caffeine_lang/generator/datadog"/utf8>>,
                                                        function => <<"ir_to_terraform_resource"/utf8>>,
                                                        line => 157,
                                                        value => _assert_fail,
                                                        start => 4896,
                                                        'end' => 4952,
                                                        pattern_start => 4907,
                                                        pattern_end => 4916}
                                                )
                                    end,
                                    {string_literal,
                                        <<<<Key/binary, ":"/utf8>>/binary,
                                            Value@1/binary>>}
                                end
                            )
                        end
                    )
                end},
            gleam@result:'try'(
                window_to_timeframe(Window_in_days),
                fun(Window_in_days_string) ->
                    Thresholds_block = terra_madre@hcl:simple_block(
                        <<"thresholds"/utf8>>,
                        [{<<"timeframe"/utf8>>,
                                {string_literal, Window_in_days_string}},
                            {<<"target"/utf8>>, {float_literal, Threshold}}]
                    ),
                    Type_str = case Slo_type of
                        time_slice_slo ->
                            <<"time_slice"/utf8>>;

                        metric_slo ->
                            <<"metric"/utf8>>
                    end,
                    {ok,
                        {resource,
                            <<"datadog_service_level_objective"/utf8>>,
                            Resource_name,
                            maps:from_list(
                                [{<<"name"/utf8>>,
                                        {string_literal,
                                            erlang:element(
                                                2,
                                                erlang:element(2, Ir)
                                            )}},
                                    {<<"type"/utf8>>,
                                        {string_literal, Type_str}},
                                    {<<"tags"/utf8>>, Tags}]
                            ),
                            lists:append(Slo_blocks, [Thresholds_block]),
                            terra_madre@hcl:empty_meta(),
                            none}}
                end
            )
        end
    ).

-file("src/caffeine_lang/generator/datadog.gleam", 25).
?DOC(
    " Generate Terraform HCL from a list of Datadog IntermediateRepresentations.\n"
    " Includes provider configuration and variables.\n"
).
-spec generate_terraform(
    list(caffeine_lang@middle_end@semantic_analyzer:intermediate_representation())
) -> {ok, binary()} | {error, caffeine_lang@common@errors:compilation_error()}.
generate_terraform(Irs) ->
    gleam@result:'try'(
        begin
            _pipe = Irs,
            gleam@list:try_map(_pipe, fun ir_to_terraform_resource/1)
        end,
        fun(Resources) ->
            Config = {config,
                {some, terraform_settings()},
                [provider()],
                Resources,
                [],
                variables(),
                [],
                [],
                []},
            {ok, terra_madre@render:render_config(Config)}
        end
    ).