-module(d1_gleamflare@internal).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/d1_gleamflare/internal.gleam").
-export([api_error_decoder/0, optional_field/2, envelope_decoder/0, base_request/1, stringify_errors/1, stringify_httpc_error/1, send_request/2]).
-export_type([envelope/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.

?MODULEDOC(false).

-type envelope() :: {envelope,
        boolean(),
        list(d1_gleamflare@types:cloudflare_api_error()),
        gleam@option:option(gleam@dynamic:dynamic_())}.

-file("src/d1_gleamflare/internal.gleam", 19).
?DOC(false).
-spec api_error_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok,
        d1_gleamflare@types:cloudflare_api_error()} |
    {error, list(gleam@dynamic:decode_error())}).
api_error_decoder() ->
    gleam@dynamic:decode2(
        fun(Field@0, Field@1) -> {cloudflare_api_error, Field@0, Field@1} end,
        gleam@dynamic:field(<<"code"/utf8>>, fun gleam@dynamic:int/1),
        gleam@dynamic:field(<<"message"/utf8>>, fun gleam@dynamic:string/1)
    ).

-file("src/d1_gleamflare/internal.gleam", 27).
?DOC(false).
-spec optional_field(
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, HAB} |
        {error, list(gleam@dynamic:decode_error())})
) -> fun((gleam@dynamic:dynamic_()) -> {ok, gleam@option:option(HAB)} |
    {error, list(gleam@dynamic:decode_error())}).
optional_field(Name, Inner) ->
    fun(D) ->
        case (gleam@dynamic:field(Name, gleam@dynamic:optional(Inner)))(D) of
            {ok, Opt} ->
                {ok, Opt};

            {error,
                [{decode_error, <<"field"/utf8>>, <<"nothing"/utf8>>, Path}]} when Path =:= [Name] ->
                {ok, none};

            {error, Errs} ->
                {error, Errs}
        end
    end.

-file("src/d1_gleamflare/internal.gleam", 40).
?DOC(false).
-spec envelope_decoder() -> fun((gleam@dynamic:dynamic_()) -> {ok, envelope()} |
    {error, list(gleam@dynamic:decode_error())}).
envelope_decoder() ->
    gleam@dynamic:decode3(
        fun(Field@0, Field@1, Field@2) -> {envelope, Field@0, Field@1, Field@2} end,
        gleam@dynamic:field(<<"success"/utf8>>, fun gleam@dynamic:bool/1),
        gleam@dynamic:field(
            <<"errors"/utf8>>,
            gleam@dynamic:list(api_error_decoder())
        ),
        optional_field(<<"result"/utf8>>, fun gleam@dynamic:dynamic/1)
    ).

-file("src/d1_gleamflare/internal.gleam", 49).
?DOC(false).
-spec base_request(d1_gleamflare@types:client()) -> gleam@http@request:request(binary()).
base_request(Client) ->
    _pipe = gleam@http@request:new(),
    _pipe@1 = gleam@http@request:set_scheme(_pipe, https),
    _pipe@2 = gleam@http@request:set_host(
        _pipe@1,
        <<"api.cloudflare.com"/utf8>>
    ),
    _pipe@3 = gleam@http@request:set_header(
        _pipe@2,
        <<"authorization"/utf8>>,
        <<"Bearer "/utf8, (erlang:element(3, Client))/binary>>
    ),
    _pipe@4 = gleam@http@request:set_header(
        _pipe@3,
        <<"content-type"/utf8>>,
        <<"application/json"/utf8>>
    ),
    _pipe@5 = gleam@http@request:set_header(
        _pipe@4,
        <<"accept"/utf8>>,
        <<"application/json"/utf8>>
    ),
    gleam@http@request:set_body(_pipe@5, <<""/utf8>>).

-file("src/d1_gleamflare/internal.gleam", 59).
?DOC(false).
-spec stringify_errors(list(gleam@dynamic:decode_error())) -> binary().
stringify_errors(Errors) ->
    _pipe = Errors,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Err) ->
            <<<<<<<<<<(erlang:element(2, Err))/binary, " at "/utf8>>/binary,
                            (gleam@string:join(
                                erlang:element(4, Err),
                                <<"."/utf8>>
                            ))/binary>>/binary,
                        " (found: "/utf8>>/binary,
                    (erlang:element(3, Err))/binary>>/binary,
                ")"/utf8>>
        end
    ),
    gleam@string:join(_pipe@1, <<", "/utf8>>).

-file("src/d1_gleamflare/internal.gleam", 116).
?DOC(false).
-spec stringify_httpc_error(any()) -> binary().
stringify_httpc_error(Err) ->
    gleam@string:inspect(Err).

-file("src/d1_gleamflare/internal.gleam", 67).
?DOC(false).
-spec send_request(
    gleam@http@request:request(binary()),
    fun((gleam@dynamic:dynamic_()) -> {ok, HAJ} |
        {error, list(gleam@dynamic:decode_error())})
) -> {ok, HAJ} | {error, d1_gleamflare@types:error()}.
send_request(Req, Result_decoder) ->
    case gleam@httpc:send(Req) of
        {ok, Res} ->
            case gleam@json:decode(erlang:element(4, Res), envelope_decoder()) of
                {ok, Envelope} ->
                    case erlang:element(2, Envelope) of
                        true ->
                            case erlang:element(4, Envelope) of
                                {some, Res_dynamic} ->
                                    case Result_decoder(Res_dynamic) of
                                        {ok, Val} ->
                                            {ok, Val};

                                        {error, Errs} ->
                                            {error,
                                                {json_error,
                                                    <<"Failed to decode response result: "/utf8,
                                                        (stringify_errors(Errs))/binary>>}}
                                    end;

                                none ->
                                    case Result_decoder(
                                        gleam_stdlib:identity(nil)
                                    ) of
                                        {ok, Val@1} ->
                                            {ok, Val@1};

                                        {error, Errs@1} ->
                                            {error,
                                                {json_error,
                                                    <<"Expected result field but it was missing: "/utf8,
                                                        (stringify_errors(
                                                            Errs@1
                                                        ))/binary>>}}
                                    end
                            end;

                        false ->
                            {error, {api_error, erlang:element(3, Envelope)}}
                    end;

                {error, Json_err} ->
                    case (erlang:element(2, Res) < 200) orelse (erlang:element(
                        2,
                        Res
                    )
                    >= 300) of
                        true ->
                            {error,
                                {http_error,
                                    erlang:element(2, Res),
                                    erlang:element(4, Res)}};

                        false ->
                            {error,
                                {json_error,
                                    <<"Failed to decode JSON: "/utf8,
                                        (gleam@string:inspect(Json_err))/binary>>}}
                    end
            end;

        {error, Httpc_err} ->
            {error, {network_error, stringify_httpc_error(Httpc_err)}}
    end.