library(R6)
library(lubridate)

# First we'll look at basic rate limiting. Suppose
# we want to limit our handling of incoming requests.
# We'll serve these requests off a queue of the same name.

requests <- c(1, 2, 3, 4, 5)

# This limiter function will return TRUE every 200 milliseconds.
# This is the regulator in our rate limiting scheme.
create_limiter <- function(interval) {
  last_check <- Sys.time()
  function() {
    now <- Sys.time()
    if (as.numeric(now - last_check, units = "secs") >= interval) {
      last_check <<- now
      return(TRUE)
    }
    return(FALSE)
  }
}

limiter <- create_limiter(0.2)  # 200 milliseconds

# By checking the limiter before processing each request,
# we limit ourselves to 1 request every 200 milliseconds.
for (req in requests) {
  while (!limiter()) {
    Sys.sleep(0.01)  # Small sleep to avoid busy waiting
  }
  cat("request", req, as.character(Sys.time()), "\n")
}

# We may want to allow short bursts of requests in
# our rate limiting scheme while preserving the
# overall rate limit. We can accomplish this by
# using a token bucket algorithm.

TokenBucket <- R6Class("TokenBucket",
  public = list(
    capacity = NULL,
    tokens = NULL,
    fill_rate = NULL,
    last_fill = NULL,
    
    initialize = function(capacity, fill_rate) {
      self$capacity <- capacity
      self$tokens <- capacity
      self$fill_rate <- fill_rate
      self$last_fill <- Sys.time()
    },
    
    consume = function(tokens = 1) {
      self$refill()
      if (self$tokens >= tokens) {
        self$tokens <- self$tokens - tokens
        return(TRUE)
      }
      return(FALSE)
    },
    
    refill = function() {
      now <- Sys.time()
      delta <- as.numeric(now - self$last_fill, units = "secs")
      self$tokens <- min(self$capacity, self$tokens + delta * self$fill_rate)
      self$last_fill <- now
    }
  )
)

# This bursty_limiter will allow bursts of up to 3 events.
bursty_limiter <- TokenBucket$new(capacity = 3, fill_rate = 5)  # 5 tokens per second

# Now simulate 5 more incoming requests. The first
# 3 of these will benefit from the burst capability
# of bursty_limiter.
bursty_requests <- c(1, 2, 3, 4, 5)

for (req in bursty_requests) {
  while (!bursty_limiter$consume()) {
    Sys.sleep(0.01)  # Small sleep to avoid busy waiting
  }
  cat("request", req, as.character(Sys.time()), "\n")
}