///|
/// A leaky bucket: capacity units of queue, draining continuously at `rate`
/// units per second. An event pours `weight` units in; if the bucket would
/// overflow the event is denied and the excess is reported. The dual of the
/// token bucket, expressed from the queue side.
priv struct LeakyBucket {
  rate : Double
  capacity : Double
  mut level : Double
  mut last : Double
}

///|
fn leaky_bucket(rate : Double, capacity : Double) -> LeakyBucket {
  // Starts empty: the bucket has no backlog.
  { rate, capacity, level: 0.0, last: 0.0, }
}

///|
/// The decision for (now, weight) against the drained level, without
/// changing the bucket; the queue-side mirror of TokenBucket::decide.
fn LeakyBucket::decide(
  self : LeakyBucket,
  now : Double,
  weight : Double,
) -> Admission {
  let elapsed = now - self.last
  let level = if elapsed > 0.0 {
    let drained = self.level - elapsed * self.rate
    if drained < 0.0 {
      0.0
    } else {
      drained
    }
  } else {
    self.level
  }
  if level + weight <= self.capacity {
    {
      allowed: true,
      retry_after: None,
      tokens: self.capacity - level - weight,
    }
  } else {
    let overflow = level + weight - self.capacity
    {
      allowed: false,
      retry_after: Some(overflow / self.rate),
      tokens: self.capacity - level,
    }
  }
}

///|
/// Applies one event: the drain fold happens for denied events too, matching
/// the single-bucket path's arithmetic exactly.
fn LeakyBucket::commit(
  self : LeakyBucket,
  now : Double,
  weight : Double,
  allowed : Bool,
) -> Unit {
  let elapsed = now - self.last
  if elapsed > 0.0 {
    let drained = self.level - elapsed * self.rate
    self.level = if drained < 0.0 { 0.0 } else { drained }
    self.last = now
  }
  if allowed {
    self.level = self.level + weight
  }
}

///|
fn LeakyBucket::check(
  self : LeakyBucket,
  now : Double,
  weight : Double,
) -> Admission {
  let decision = self.decide(now, weight)
  self.commit(now, weight, decision.allowed)
  decision
}