-module(glean@providers@http_utils).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glean/providers/http_utils.gleam").
-export([send_post/5]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-file("src/glean/providers/http_utils.gleam", 53).
?DOC(false).
-spec apply_headers(
    gleam@http@request:request(binary()),
    list({binary(), binary()})
) -> gleam@http@request:request(binary()).
apply_headers(Req, Headers) ->
    gleam@list:fold(
        Headers,
        Req,
        fun(R, Header) ->
            gleam@http@request:set_header(
                R,
                erlang:element(1, Header),
                erlang:element(2, Header)
            )
        end
    ).

-file("src/glean/providers/http_utils.gleam", 113).
?DOC(false).
-spec is_retryable(integer()) -> boolean().
is_retryable(Status) ->
    ((((Status =:= 429) orelse (Status =:= 500)) orelse (Status =:= 502)) orelse (Status
    =:= 503))
    orelse (Status =:= 504).

-file("src/glean/providers/http_utils.gleam", 62).
?DOC(false).
-spec send_with_retry(
    gleam@http@request:request(binary()),
    glean@providers@config:provider_config(),
    binary(),
    integer(),
    integer()
) -> {ok, binary()} | {error, glean@error:glean_error()}.
send_with_retry(Req, Config, Provider_name, Attempt, Delay_ms) ->
    Http_result = begin
        _pipe = gleam@httpc:configure(),
        _pipe@1 = gleam@httpc:timeout(_pipe, erlang:element(6, Config)),
        gleam@httpc:dispatch(_pipe@1, Req)
    end,
    case Http_result of
        {error, response_timeout} ->
            {error, {timeout, erlang:element(6, Config)}};

        {error, _} ->
            {error,
                {provider_error,
                    Provider_name,
                    erlang:element(4, Config),
                    0,
                    <<"HTTP request failed"/utf8>>}};

        {ok, Resp} ->
            case erlang:element(2, Resp) of
                200 ->
                    {ok, erlang:element(4, Resp)};

                Status ->
                    case is_retryable(Status) andalso (Attempt < erlang:element(
                        8,
                        Config
                    )) of
                        true ->
                            gleam_erlang_ffi:sleep(Delay_ms),
                            send_with_retry(
                                Req,
                                Config,
                                Provider_name,
                                Attempt + 1,
                                Delay_ms * 2
                            );

                        false ->
                            {error,
                                {provider_error,
                                    Provider_name,
                                    erlang:element(4, Config),
                                    Status,
                                    erlang:element(4, Resp)}}
                    end
            end
    end.

-file("src/glean/providers/http_utils.gleam", 14).
?DOC(false).
-spec send_post(
    glean@providers@config:provider_config(),
    binary(),
    binary(),
    binary(),
    list({binary(), binary()})
) -> {ok, binary()} | {error, glean@error:glean_error()}.
send_post(Config, Provider_name, Url, Body, Extra_headers) ->
    Req_result = begin
        _pipe = gleam@http@request:to(Url),
        gleam@result:map_error(
            _pipe,
            fun(_) -> {config_error, <<"Invalid URL: "/utf8, Url/binary>>} end
        )
    end,
    case Req_result of
        {error, Err} ->
            {error, Err};

        {ok, Req} ->
            Req@1 = begin
                _pipe@1 = Req,
                _pipe@2 = gleam@http@request:set_method(_pipe@1, post),
                _pipe@3 = gleam@http@request:set_header(
                    _pipe@2,
                    <<"content-type"/utf8>>,
                    <<"application/json"/utf8>>
                ),
                _pipe@4 = gleam@http@request:set_body(_pipe@3, Body),
                _pipe@5 = apply_headers(_pipe@4, Extra_headers),
                apply_headers(
                    _pipe@5,
                    gleam@list:map(
                        erlang:element(5, Config),
                        fun(H) ->
                            {erlang:element(1, H), erlang:element(2, H)}
                        end
                    )
                )
            end,
            send_with_retry(
                Req@1,
                Config,
                Provider_name,
                0,
                erlang:element(9, Config)
            )
    end.