-module(glimit).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/0, per_second/2, per_minute/2, per_hour/2, handler/2, identifier/2, build/1, apply/2, stop/1]).
-export_type([message/1, rate_limiter/3, rate_limiter_builder/3, state/3]).

-type message(HNG) :: shutdown |
    {hit, HNG, gleam@erlang@process:subject({ok, nil} | {error, nil})}.

-type rate_limiter(HNH, HNI, HNJ) :: {rate_limiter,
        gleam@erlang@process:subject(message(HNJ)),
        fun((HNH) -> HNI),
        fun((HNH) -> HNJ)}.

-type rate_limiter_builder(HNK, HNL, HNM) :: {rate_limiter_builder,
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(fun((HNK) -> HNM)),
        gleam@option:option(fun((HNK) -> HNL))}.

-type state(HNN, HNO, HNP) :: {rate_limiter_state,
        gleam@dict:dict(HNP, list(integer())),
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(integer())} |
    {gleam_phantom, HNN, HNO}.

-spec handle_message(message(HNQ), state(HNS, HNT, HNQ)) -> gleam@otp@actor:next(message(HNQ), state(HNS, HNT, HNQ)).
handle_message(Message, State) ->
    case Message of
        shutdown ->
            {stop, normal};

        {hit, Identifier, Client} ->
            Timestamp = glimit@utils:now(),
            Hits = begin
                _pipe = erlang:element(2, State),
                _pipe@1 = gleam@dict:get(_pipe, Identifier),
                _pipe@2 = gleam@result:unwrap(_pipe@1, []),
                _pipe@3 = gleam@list:filter(
                    _pipe@2,
                    fun(Hit) -> Hit >= (Timestamp - (60 * 60)) end
                ),
                lists:append(_pipe@3, [Timestamp])
            end,
            Hit_log = begin
                _pipe@4 = erlang:element(2, State),
                gleam@dict:insert(_pipe@4, Identifier, Hits)
            end,
            State@1 = erlang:setelement(2, State, Hit_log),
            Hits_last_hour = begin
                _pipe@5 = Hits,
                erlang:length(_pipe@5)
            end,
            Hits_last_minute = begin
                _pipe@6 = Hits,
                _pipe@7 = gleam@list:filter(
                    _pipe@6,
                    fun(Hit@1) -> Hit@1 >= (Timestamp - 60) end
                ),
                erlang:length(_pipe@7)
            end,
            Hits_last_second = begin
                _pipe@8 = Hits,
                _pipe@9 = gleam@list:filter(
                    _pipe@8,
                    fun(Hit@2) -> Hit@2 >= (Timestamp - 1) end
                ),
                erlang:length(_pipe@9)
            end,
            Limit_reached = ((case erlang:element(5, State@1) of
                {some, Limit} ->
                    Hits_last_hour > Limit;

                none ->
                    false
            end orelse case erlang:element(4, State@1) of
                {some, Limit@1} ->
                    Hits_last_minute > Limit@1;

                none ->
                    false
            end) orelse case erlang:element(3, State@1) of
                {some, Limit@2} ->
                    Hits_last_second > Limit@2;

                none ->
                    false
            end),
            case Limit_reached of
                true ->
                    gleam@erlang@process:send(Client, {error, nil});

                false ->
                    gleam@erlang@process:send(Client, {ok, nil})
            end,
            gleam@otp@actor:continue(State@1)
    end.

-spec new() -> rate_limiter_builder(any(), any(), any()).
new() ->
    {rate_limiter_builder, none, none, none, none, none}.

-spec per_second(rate_limiter_builder(HOJ, HOK, HOL), integer()) -> rate_limiter_builder(HOJ, HOK, HOL).
per_second(Limiter, Limit) ->
    erlang:setelement(2, Limiter, {some, Limit}).

-spec per_minute(rate_limiter_builder(HOS, HOT, HOU), integer()) -> rate_limiter_builder(HOS, HOT, HOU).
per_minute(Limiter, Limit) ->
    erlang:setelement(3, Limiter, {some, Limit}).

-spec per_hour(rate_limiter_builder(HPB, HPC, HPD), integer()) -> rate_limiter_builder(HPB, HPC, HPD).
per_hour(Limiter, Limit) ->
    erlang:setelement(4, Limiter, {some, Limit}).

-spec handler(rate_limiter_builder(HPK, HPL, HPM), fun((HPK) -> HPL)) -> rate_limiter_builder(HPK, HPL, HPM).
handler(Limiter, Handler) ->
    erlang:setelement(6, Limiter, {some, Handler}).

-spec identifier(rate_limiter_builder(HPT, HPU, HPV), fun((HPT) -> HPV)) -> rate_limiter_builder(HPT, HPU, HPV).
identifier(Limiter, Identifier) ->
    erlang:setelement(5, Limiter, {some, Identifier}).

-spec build(rate_limiter_builder(HQC, HQD, HQE)) -> rate_limiter(HQC, HQD, HQE).
build(Config) ->
    State = {rate_limiter_state,
        gleam@dict:new(),
        erlang:element(2, Config),
        erlang:element(3, Config),
        erlang:element(4, Config)},
    {rate_limiter, case gleam@otp@actor:start(State, fun handle_message/2) of
            {ok, Subject} ->
                Subject;

            {error, _} ->
                erlang:error(#{gleam_error => panic,
                        message => <<"Failed to start rate limiter actor"/utf8>>,
                        module => <<"glimit"/utf8>>,
                        function => <<"build"/utf8>>,
                        line => 222})
        end, case erlang:element(6, Config) of
            {some, Handler} ->
                Handler;

            none ->
                erlang:error(#{gleam_error => panic,
                        message => <<"Handler function is required"/utf8>>,
                        module => <<"glimit"/utf8>>,
                        function => <<"build"/utf8>>,
                        line => 230})
        end, case erlang:element(5, Config) of
            {some, Identifier} ->
                Identifier;

            none ->
                erlang:error(#{gleam_error => panic,
                        message => <<"Identifier function is required"/utf8>>,
                        module => <<"glimit"/utf8>>,
                        function => <<"build"/utf8>>,
                        line => 226})
        end}.

-spec apply(fun((HQL) -> HQM), rate_limiter(HQL, HQM, any())) -> fun((HQL) -> HQM).
apply(Func, Limiter) ->
    fun(Input) ->
        Identifier = (erlang:element(4, Limiter))(Input),
        case gleam@otp@actor:call(
            erlang:element(2, Limiter),
            fun(_capture) -> {hit, Identifier, _capture} end,
            10
        ) of
            {ok, nil} ->
                Func(Input);

            {error, nil} ->
                (erlang:element(3, Limiter))(Input)
        end
    end.

-spec stop(rate_limiter(any(), any(), any())) -> nil.
stop(Limiter) ->
    gleam@otp@actor:send(erlang:element(2, Limiter), shutdown).