-module(glimit).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glimit.gleam").
-export([new/0, per_second/2, per_second_fn/2, burst_limit/2, burst_limit_fn/2, max_idle/2, store/2, on_limit_exceeded/2, identifier/2, build/1, get_count/1, hit/2, apply_built/2, apply/2, remove/2, apply2/2, apply3/2, apply4/2]).
-export_type([hit_error/0, rate_limiter/3, rate_limiter_builder/3]).

-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(
    " This module provides a rate limiter that can be used to limit the number of\n"
    " requests or function calls per second for a given identifier.\n"
    "\n"
    " In-memory mode: each hit sends two messages to an OTP actor (get + set).\n"
    " A periodic sweep removes full or idle buckets to reduce memory usage. The\n"
    " idle threshold defaults to 60 seconds and can be configured via `max_idle`.\n"
    "\n"
    " External store mode: each hit calls the store's lock_and_get/set_and_unlock\n"
    " interface directly, with no actor overhead.\n"
    "\n"
    " The rate limiter fails open — if the store is unavailable, requests are\n"
    " allowed through.\n"
    "\n"
    " The rate limits are configured using the following two options:\n"
    "\n"
    " - `per_second`: The rate of new available tokens per second. Think of this\n"
    "   as the steady state rate limit.\n"
    " - `burst_limit`: The maximum number of available tokens. Think of this as\n"
    "   the burst rate limit. The default value is the `per_second` rate limit.\n"
    "\n"
    " The rate limiter can be applied to a function or handler using the `apply`\n"
    " function, which returns a new function that checks the rate limit before\n"
    " calling the original function.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.burst_limit(100)\n"
    "   |> glimit.identifier(fn(request) { request.ip })\n"
    "   |> glimit.on_limit_exceeded(fn(_request) { \"Rate limit reached\" })\n"
    "\n"
    " let handler =\n"
    "   fn(_request) { \"Hello, world!\" }\n"
    "   |> glimit.apply(limiter)\n"
    " ```\n"
    "\n"
    " # Multi-argument functions\n"
    "\n"
    " `apply` wraps a single-argument function `fn(a) -> b`. To rate-limit a\n"
    " function with multiple arguments, use `apply2`, `apply3`, or `apply4`:\n"
    "\n"
    " ```gleam\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.identifier(fn(args: #(String, String)) { args.0 })\n"
    "   |> glimit.on_limit_exceeded(fn(_args) { too_many_requests() })\n"
    "\n"
    " let limited_handle =\n"
    "   handle\n"
    "   |> glimit.apply2(limiter)\n"
    "\n"
    " limited_handle(\"user_123\", \"upload\")\n"
    " ```\n"
    "\n"
    " # Pluggable store backend\n"
    "\n"
    " By default, rate limit state is stored in-memory using an OTP actor. For\n"
    " distributed rate limiting (e.g. across multiple nodes), you can provide a\n"
    " custom `Store` that persists bucket state externally (Redis, Postgres, etc.).\n"
    "\n"
    " All token bucket logic stays in glimit — adapters only implement\n"
    " `lock_and_get` / `set_and_unlock` / `unlock` operations. The `glimit/bucket`\n"
    " module is public and provides `to_pairs`/`from_pairs` helpers for\n"
    " serialization.\n"
    "\n"
    " See `examples/redis/` for a complete Redis adapter using\n"
    " [valkyrie](https://hexdocs.pm/valkyrie/).\n"
    "\n"
).

-type hit_error() :: rate_limited | unavailable | store_lock_failed.

-type rate_limiter(FVK, FVL, FVM) :: {rate_limiter,
        fun((FVK) -> FVL),
        fun((FVK) -> FVM),
        fun((FVM) -> integer()),
        fun((FVM) -> integer()),
        glimit@bucket:store(),
        gleam@option:option(glimit@memory_store:memory_store()),
        fun(() -> integer())}.

-type rate_limiter_builder(FVN, FVO, FVP) :: {rate_limiter_builder,
        gleam@option:option(fun((FVP) -> integer())),
        gleam@option:option(fun((FVP) -> integer())),
        gleam@option:option(fun((FVN) -> FVP)),
        gleam@option:option(fun((FVN) -> FVO)),
        gleam@option:option(integer()),
        gleam@option:option(glimit@bucket:store())}.

-file("src/glimit.gleam", 131).
?DOC(" Create a new rate limiter builder.\n").
-spec new() -> rate_limiter_builder(any(), any(), any()).
new() ->
    {rate_limiter_builder, none, none, none, none, {some, 60000}, none}.

-file("src/glimit.gleam", 161).
?DOC(
    " Set the rate of new available tokens per second.\n"
    "\n"
    " Note that this is not the maximum number of requests that can be made in a single\n"
    " second, but the rate at which tokens are added to the bucket. Think of this as the\n"
    " steady state rate limit, while the `burst_limit` function sets the maximum number of\n"
    " available tokens (or the burst rate limit).\n"
    "\n"
    " This value is also used as the default value for the `burst_limit` function.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    " ```\n"
).
-spec per_second(rate_limiter_builder(FVW, FVX, FVY), integer()) -> rate_limiter_builder(FVW, FVX, FVY).
per_second(Limiter, Limit) ->
    {rate_limiter_builder,
        {some, fun(_) -> Limit end},
        erlang:element(3, Limiter),
        erlang:element(4, Limiter),
        erlang:element(5, Limiter),
        erlang:element(6, Limiter),
        erlang:element(7, Limiter)}.

-file("src/glimit.gleam", 188).
?DOC(
    " Set the rate limit per second, based on the identifier.\n"
    "\n"
    " Note: this function is evaluated once when a bucket is first created for an\n"
    " identifier. If the function returns a different value later, existing buckets\n"
    " are not affected until they are swept (due to idleness or being full) and\n"
    " re-created on the next hit.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.identifier(fn(request) { request.user_id })\n"
    "   |> glimit.per_second_fn(fn(user_id) {\n"
    "     db.get_rate_limit(user_id)\n"
    "   })\n"
    " ```\n"
).
-spec per_second_fn(
    rate_limiter_builder(FWF, FWG, FWH),
    fun((FWH) -> integer())
) -> rate_limiter_builder(FWF, FWG, FWH).
per_second_fn(Limiter, Limit_fn) ->
    {rate_limiter_builder,
        {some, Limit_fn},
        erlang:element(3, Limiter),
        erlang:element(4, Limiter),
        erlang:element(5, Limiter),
        erlang:element(6, Limiter),
        erlang:element(7, Limiter)}.

-file("src/glimit.gleam", 212).
?DOC(
    " Set the maximum number of available tokens.\n"
    "\n"
    " The maximum number of available tokens is the maximum number of requests that can be\n"
    " made in a single burst when the bucket is full. The default value is the same as the\n"
    " rate limit per second.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.burst_limit(100)\n"
    " ```\n"
).
-spec burst_limit(rate_limiter_builder(FWO, FWP, FWQ), integer()) -> rate_limiter_builder(FWO, FWP, FWQ).
burst_limit(Limiter, Burst_limit) ->
    {rate_limiter_builder,
        erlang:element(2, Limiter),
        {some, fun(_) -> Burst_limit end},
        erlang:element(4, Limiter),
        erlang:element(5, Limiter),
        erlang:element(6, Limiter),
        erlang:element(7, Limiter)}.

-file("src/glimit.gleam", 240).
?DOC(
    " Set the maximum number of available tokens, based on the identifier.\n"
    "\n"
    " Note: this function is evaluated once when a bucket is first created for an\n"
    " identifier. If the function returns a different value later, existing buckets\n"
    " are not affected until they are swept (due to idleness or being full) and\n"
    " re-created on the next hit.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.identifier(fn(request) { request.user_id })\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.burst_limit_fn(fn(user_id) {\n"
    "     db.get_burst_limit(user_id)\n"
    "   })\n"
    " ```\n"
).
-spec burst_limit_fn(
    rate_limiter_builder(FWX, FWY, FWZ),
    fun((FWZ) -> integer())
) -> rate_limiter_builder(FWX, FWY, FWZ).
burst_limit_fn(Limiter, Burst_limit_fn) ->
    {rate_limiter_builder,
        erlang:element(2, Limiter),
        {some, Burst_limit_fn},
        erlang:element(4, Limiter),
        erlang:element(5, Limiter),
        erlang:element(6, Limiter),
        erlang:element(7, Limiter)}.

-file("src/glimit.gleam", 270).
?DOC(
    " Set the idle eviction threshold in seconds.\n"
    "\n"
    " Buckets that have not been hit for longer than this duration are removed\n"
    " during periodic sweeps. The default is 60 seconds. Set to `0` to disable\n"
    " idle eviction entirely.\n"
    "\n"
    " For rate limiters with a high `burst_limit` relative to `per_second`, you\n"
    " may want to increase this value so that partially-refilled buckets are not\n"
    " evicted prematurely. A good rule of thumb is\n"
    " `burst_limit / per_second` seconds.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(1)\n"
    "   |> glimit.burst_limit(1000)\n"
    "   |> glimit.max_idle(1000)\n"
    " ```\n"
).
-spec max_idle(rate_limiter_builder(FXG, FXH, FXI), integer()) -> rate_limiter_builder(FXG, FXH, FXI).
max_idle(Limiter, Seconds) ->
    case Seconds of
        S when S =< 0 ->
            {rate_limiter_builder,
                erlang:element(2, Limiter),
                erlang:element(3, Limiter),
                erlang:element(4, Limiter),
                erlang:element(5, Limiter),
                none,
                erlang:element(7, Limiter)};

        S@1 ->
            {rate_limiter_builder,
                erlang:element(2, Limiter),
                erlang:element(3, Limiter),
                erlang:element(4, Limiter),
                erlang:element(5, Limiter),
                {some, S@1 * 1000},
                erlang:element(7, Limiter)}
    end.

-file("src/glimit.gleam", 299).
?DOC(
    " Set a pluggable store backend for distributed rate limiting.\n"
    "\n"
    " When a store is configured, bucket state is read from and written to the\n"
    " store on each hit instead of being kept in memory.\n"
    " External stores handle expiry via TTL.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.store(my_redis_store)\n"
    "   |> glimit.identifier(fn(request) { request.ip })\n"
    "   |> glimit.on_limit_exceeded(fn(_request) { \"Rate limit reached\" })\n"
    " ```\n"
).
-spec store(rate_limiter_builder(FXP, FXQ, FXR), glimit@bucket:store()) -> rate_limiter_builder(FXP, FXQ, FXR).
store(Limiter, Store) ->
    {rate_limiter_builder,
        erlang:element(2, Limiter),
        erlang:element(3, Limiter),
        erlang:element(4, Limiter),
        erlang:element(5, Limiter),
        erlang:element(6, Limiter),
        {some, Store}}.

-file("src/glimit.gleam", 319).
?DOC(
    " Set the handler to be called when the rate limit is reached.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.on_limit_exceeded(fn(_request) { \"Rate limit reached\" })\n"
    " ```\n"
).
-spec on_limit_exceeded(rate_limiter_builder(FXY, FXZ, FYA), fun((FXY) -> FXZ)) -> rate_limiter_builder(FXY, FXZ, FYA).
on_limit_exceeded(Limiter, On_limit_exceeded) ->
    {rate_limiter_builder,
        erlang:element(2, Limiter),
        erlang:element(3, Limiter),
        erlang:element(4, Limiter),
        {some, On_limit_exceeded},
        erlang:element(6, Limiter),
        erlang:element(7, Limiter)}.

-file("src/glimit.gleam", 338).
?DOC(
    " Set the identifier function to be used to identify the rate limit.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " import glimit\n"
    "\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.identifier(fn(request) { request.ip })\n"
    " ```\n"
).
-spec identifier(rate_limiter_builder(FYH, FYI, FYJ), fun((FYH) -> FYJ)) -> rate_limiter_builder(FYH, FYI, FYJ).
identifier(Limiter, Identifier) ->
    {rate_limiter_builder,
        erlang:element(2, Limiter),
        erlang:element(3, Limiter),
        {some, Identifier},
        erlang:element(5, Limiter),
        erlang:element(6, Limiter),
        erlang:element(7, Limiter)}.

-file("src/glimit.gleam", 349).
-spec store_hit(
    glimit@bucket:store(),
    fun(() -> integer()),
    binary(),
    integer(),
    integer()
) -> {ok, nil} | {error, hit_error()}.
store_hit(Store, Now, Key, Max_token_count, Token_rate) ->
    gleam@result:'try'(
        begin
            _pipe = (erlang:element(2, Store))(Key),
            gleam@result:replace_error(_pipe, store_lock_failed)
        end,
        fun(Maybe_bucket) ->
            B@1 = case Maybe_bucket of
                {some, B} ->
                    {ok, B};

                none ->
                    glimit@bucket:new(Max_token_count, Token_rate)
            end,
            case B@1 of
                {error, _} ->
                    _ = (erlang:element(4, Store))(Key),
                    {error, unavailable};

                {ok, B@2} ->
                    {Hit_result, New_b} = glimit@bucket:hit(B@2, Now()),
                    Ttl = glimit@bucket:compute_ttl(New_b),
                    _ = (erlang:element(3, Store))(Key, New_b, Ttl),
                    case Hit_result of
                        {ok, nil} ->
                            {ok, nil};

                        {error, nil} ->
                            {error, rate_limited}
                    end
            end
        end
    ).

-file("src/glimit.gleam", 389).
?DOC(
    " Build the rate limiter.\n"
    "\n"
    " Note that using `apply` will already build the rate limiter, so this function is\n"
    " only useful if you want to build the rate limiter manually and apply it to multiple\n"
    " functions.\n"
    "\n"
    " To apply the resulting rate limiter to a function or handler, use the `apply_built`\n"
    " function.\n"
).
-spec build(rate_limiter_builder(FYT, FYU, FYV)) -> {ok,
        rate_limiter(FYT, FYU, FYV)} |
    {error, binary()}.
build(Config) ->
    gleam@result:'try'(case erlang:element(2, Config) of
            {some, Per_second} ->
                {ok, Per_second};

            none ->
                {error, <<"`per_second` rate limit is required"/utf8>>}
        end, fun(Per_second@1) ->
            Burst_limit@1 = case erlang:element(3, Config) of
                {some, Burst_limit} ->
                    Burst_limit;

                none ->
                    Per_second@1
            end,
            gleam@result:'try'(case erlang:element(4, Config) of
                    {some, Identifier} ->
                        {ok, Identifier};

                    none ->
                        {error, <<"`identifier` function is required"/utf8>>}
                end, fun(Identifier@1) ->
                    gleam@result:'try'(case erlang:element(5, Config) of
                            {some, On_limit_exceeded} ->
                                {ok, On_limit_exceeded};

                            none ->
                                {error,
                                    <<"`on_limit_exceeded` function is required"/utf8>>}
                        end, fun(On_limit_exceeded@1) ->
                            gleam@result:'try'(case erlang:element(7, Config) of
                                    {some, Ext_store} ->
                                        {ok, {Ext_store, none}};

                                    none ->
                                        case glimit@memory_store:new(
                                            erlang:element(6, Config),
                                            10000
                                        ) of
                                            {ok, Handle} ->
                                                {ok,
                                                    {glimit@memory_store:make_store(
                                                            Handle
                                                        ),
                                                        {some, Handle}}};

                                            {error, _} ->
                                                {error,
                                                    <<"Failed to start memory store"/utf8>>}
                                        end
                                end, fun(_use0) ->
                                    {Store, Ms} = _use0,
                                    {ok,
                                        {rate_limiter,
                                            On_limit_exceeded@1,
                                            Identifier@1,
                                            Per_second@1,
                                            Burst_limit@1,
                                            Store,
                                            Ms,
                                            fun glimit@utils:now/0}}
                                end)
                        end)
                end)
        end).

-file("src/glimit.gleam", 485).
?DOC(
    " Return the number of tracked identifiers in the in-memory store.\n"
    "\n"
    " Returns 0 if the rate limiter uses an external store.\n"
).
-spec get_count(rate_limiter(any(), any(), any())) -> integer().
get_count(Limiter) ->
    case erlang:element(7, Limiter) of
        {some, Ms} ->
            glimit@memory_store:get_count(Ms);

        none ->
            0
    end.

-file("src/glimit.gleam", 345).
-spec string_key(any()) -> binary().
string_key(Identifier) ->
    <<"glimit:"/utf8, (gleam@string:inspect(Identifier))/binary>>.

-file("src/glimit.gleam", 431).
?DOC(" Hit the rate limiter for the given identifier directly.\n").
-spec hit(rate_limiter(any(), any(), FZG), FZG) -> {ok, nil} |
    {error, hit_error()}.
hit(Limiter, Identifier) ->
    Key = string_key(Identifier),
    case glimit_ffi:rescue(
        fun() -> (erlang:element(5, Limiter))(Identifier) end
    ) of
        {error, _} ->
            {error, unavailable};

        {ok, Max} ->
            case glimit_ffi:rescue(
                fun() -> (erlang:element(4, Limiter))(Identifier) end
            ) of
                {error, _} ->
                    {error, unavailable};

                {ok, Rate} ->
                    store_hit(
                        erlang:element(6, Limiter),
                        erlang:element(8, Limiter),
                        Key,
                        Max,
                        Rate
                    )
            end
    end.

-file("src/glimit.gleam", 467).
?DOC(
    " Apply the rate limiter to a request handler or function.\n"
    "\n"
    " This function is useful if you want to build the rate limiter manually using the\n"
    " `build` function.\n"
).
-spec apply_built(fun((FZS) -> FZT), rate_limiter(FZS, FZT, any())) -> fun((FZS) -> FZT).
apply_built(Func, Limiter) ->
    fun(Input) ->
        Identifier = (erlang:element(3, Limiter))(Input),
        case hit(Limiter, Identifier) of
            {ok, nil} ->
                Func(Input);

            {error, rate_limited} ->
                (erlang:element(2, Limiter))(Input);

            {error, unavailable} ->
                Func(Input);

            {error, store_lock_failed} ->
                Func(Input)
        end
    end.

-file("src/glimit.gleam", 451).
?DOC(
    " Apply the rate limiter to a request handler or function.\n"
    "\n"
    " Panics if the rate limiter cannot be started or if the `identifier`\n"
    " function or `on_limit_exceeded` function is missing.\n"
).
-spec apply(fun((FZM) -> FZN), rate_limiter_builder(FZM, FZN, any())) -> fun((FZM) -> FZN).
apply(Func, Config) ->
    Limiter@1 = case build(Config) of
        {ok, Limiter} ->
            Limiter;

        {error, Message} ->
            erlang:error(#{gleam_error => panic,
                    message => Message,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"glimit"/utf8>>,
                    function => <<"apply"/utf8>>,
                    line => 457})
    end,
    apply_built(Func, Limiter@1).

-file("src/glimit.gleam", 496).
?DOC(
    " Remove an identifier from the in-memory store.\n"
    "\n"
    " No-op if the rate limiter uses an external store.\n"
).
-spec remove(rate_limiter(any(), any(), GAG), GAG) -> nil.
remove(Limiter, Identifier) ->
    case erlang:element(7, Limiter) of
        {some, Ms} ->
            Key = string_key(Identifier),
            _ = glimit@memory_store:remove(Ms, Key),
            nil;

        none ->
            nil
    end.

-file("src/glimit.gleam", 527).
?DOC(
    " Apply the rate limiter to a 2-argument function.\n"
    "\n"
    " The config's `identifier` and `on_limit_exceeded` receive a `#(a, b)` tuple.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.identifier(fn(args: #(String, String)) { args.0 })\n"
    "   |> glimit.on_limit_exceeded(fn(_) { \"Rate limited\" })\n"
    "\n"
    " let limited =\n"
    "   handle\n"
    "   |> glimit.apply2(limiter)\n"
    "\n"
    " limited(\"user_123\", \"upload\")\n"
    " ```\n"
).
-spec apply2(
    fun((GAK, GAL) -> GAM),
    rate_limiter_builder({GAK, GAL}, GAM, any())
) -> fun((GAK, GAL) -> GAM).
apply2(Func, Config) ->
    Wrapped = begin
        _pipe = fun(Args) ->
            Func(erlang:element(1, Args), erlang:element(2, Args))
        end,
        apply(_pipe, Config)
    end,
    fun(A, B) -> Wrapped({A, B}) end.

-file("src/glimit.gleam", 557).
?DOC(
    " Apply the rate limiter to a 3-argument function.\n"
    "\n"
    " The config's `identifier` and `on_limit_exceeded` receive a `#(a, b, c)` tuple.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.identifier(fn(args: #(String, String, Int)) { args.0 })\n"
    "   |> glimit.on_limit_exceeded(fn(_) { \"Rate limited\" })\n"
    "\n"
    " let limited =\n"
    "   handle\n"
    "   |> glimit.apply3(limiter)\n"
    "\n"
    " limited(\"user_123\", \"upload\", 42)\n"
    " ```\n"
).
-spec apply3(
    fun((GAR, GAS, GAT) -> GAU),
    rate_limiter_builder({GAR, GAS, GAT}, GAU, any())
) -> fun((GAR, GAS, GAT) -> GAU).
apply3(Func, Config) ->
    Wrapped = begin
        _pipe = fun(Args) ->
            Func(
                erlang:element(1, Args),
                erlang:element(2, Args),
                erlang:element(3, Args)
            )
        end,
        apply(_pipe, Config)
    end,
    fun(A, B, C) -> Wrapped({A, B, C}) end.

-file("src/glimit.gleam", 587).
?DOC(
    " Apply the rate limiter to a 4-argument function.\n"
    "\n"
    " The config's `identifier` and `on_limit_exceeded` receive a `#(a, b, c, d)` tuple.\n"
    "\n"
    " # Example\n"
    "\n"
    " ```gleam\n"
    " let limiter =\n"
    "   glimit.new()\n"
    "   |> glimit.per_second(10)\n"
    "   |> glimit.identifier(fn(args: #(String, String, Int, Bool)) { args.0 })\n"
    "   |> glimit.on_limit_exceeded(fn(_) { \"Rate limited\" })\n"
    "\n"
    " let limited =\n"
    "   handle\n"
    "   |> glimit.apply4(limiter)\n"
    "\n"
    " limited(\"user_123\", \"upload\", 42, True)\n"
    " ```\n"
).
-spec apply4(
    fun((GAZ, GBA, GBB, GBC) -> GBD),
    rate_limiter_builder({GAZ, GBA, GBB, GBC}, GBD, any())
) -> fun((GAZ, GBA, GBB, GBC) -> GBD).
apply4(Func, Config) ->
    Wrapped = begin
        _pipe = fun(Args) ->
            Func(
                erlang:element(1, Args),
                erlang:element(2, Args),
                erlang:element(3, Args),
                erlang:element(4, Args)
            )
        end,
        apply(_pipe, Config)
    end,
    fun(A, B, C, D) -> Wrapped({A, B, C, D}) end.