glimit

-module(glimit@bucket).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glimit/bucket.gleam").
-export([new/2, refill/2, hit/2, is_full/2]).
-export_type([bucket_state/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 bucket_state() :: {bucket_state,
        integer(),
        integer(),
        float(),
        gleam@option:option(integer())}.

-file("src/glimit/bucket.gleam", 31).
?DOC(false).
-spec new(integer(), integer()) -> {ok, bucket_state()} | {error, nil}.
new(Max_token_count, Token_rate) ->
    case (Max_token_count > 0) andalso (Token_rate > 0) of
        false ->
            {error, nil};

        true ->
            {ok,
                {bucket_state,
                    Max_token_count,
                    Token_rate,
                    erlang:float(Max_token_count),
                    none}}
    end.

-file("src/glimit/bucket.gleam", 46).
?DOC(false).
-spec refill(bucket_state(), integer()) -> bucket_state().
refill(State, Now) ->
    Time_diff = case erlang:element(5, State) of
        none ->
            0;

        {some, Last_update} ->
            gleam@int:max(0, Now - Last_update)
    end,
    Tokens_to_add = erlang:float(erlang:element(3, State) * Time_diff) / 1000.0,
    Token_count = begin
        _pipe = (erlang:element(4, State) + Tokens_to_add),
        _pipe@1 = gleam@float:min(_pipe, erlang:float(erlang:element(2, State))),
        gleam@float:max(_pipe@1, +0.0)
    end,
    Last_update@1 = case Time_diff > 0 of
        true ->
            {some, Now};

        false ->
            case erlang:element(5, State) of
                none ->
                    {some, Now};

                {some, _} ->
                    erlang:element(5, State)
            end
    end,
    {bucket_state,
        erlang:element(2, State),
        erlang:element(3, State),
        Token_count,
        Last_update@1}.

-file("src/glimit/bucket.gleam", 73).
?DOC(false).
-spec hit(bucket_state(), integer()) -> {{ok, nil} | {error, nil},
    bucket_state()}.
hit(State, Now) ->
    State@1 = refill(State, Now),
    case erlang:element(4, State@1) >= 1.0 of
        true ->
            {{ok, nil},
                {bucket_state,
                    erlang:element(2, State@1),
                    erlang:element(3, State@1),
                    erlang:element(4, State@1) - 1.0,
                    erlang:element(5, State@1)}};

        false ->
            {{error, nil}, State@1}
    end.

-file("src/glimit/bucket.gleam", 86).
?DOC(false).
-spec is_full(bucket_state(), integer()) -> boolean().
is_full(State, Now) ->
    State@1 = refill(State, Now),
    erlang:element(4, State@1) >= erlang:float(erlang:element(2, State@1)).