///|
pub(all) enum CollectError {
  WindowFailure(WindowError)
  ShardFailure(ShardError)
  UnitMismatch
  IncompatibleTimeBucket
  ConflictingIdentity
  IdentityBudget
}

///|
pub(all) enum Receipt {
  Added
  Duplicate
}

///|
pub struct Collector {
  priv mut window : Window
  priv unit : LatencyUnit
  priv capacity : Int32
  priv mut seen : Map[(Int64, Int64), Shard]
}

///|
pub fn Collector::new(
  unit : LatencyUnit,
  width : Int64,
  slots : Int32,
  identities~ : Int32 = 1024,
) -> Result[Collector, CollectError] {
  if identities < 1 || identities > 4096 {
    return Err(IdentityBudget)
  }
  match Window::new(width, slots) {
    Ok(window) => Ok({ window, unit, capacity: identities, seen: Map([]), })
    Err(error) => Err(WindowFailure(error))
  }
}

///|
fn Collector::expired(self : Collector, epoch : Int64) -> Array[(Int64, Int64)] {
  let result : Array[(Int64, Int64)] = []
  let oldest = epoch - self.window.slots.length().to_int64() + 1L
  if epoch > self.window.latest {
    for id, shard in self.seen {
      if shard.timestamp / self.window.width < oldest {
        result.push(id)
      }
    }
  }
  result
}

///|
pub fn Collector::receive(
  self : Collector,
  shard : Shard,
) -> Result[Receipt, CollectError] {
  if shard.unit.tag() != self.unit.tag() {
    return Err(UnitMismatch)
  }
  if shard.width > 0L {
    let remaining = MAX_COUNT - shard.timestamp
    let coverage = if shard.width - 1L > remaining {
      remaining
    } else {
      shard.width - 1L
    }
    if coverage >= self.window.width - shard.timestamp % self.window.width {
      return Err(IncompatibleTimeBucket)
    }
  }
  let id = shard.identity()
  if self.seen.get(id) is Some(previous) {
    if previous.timestamp == shard.timestamp &&
      previous.width == shard.width &&
      previous.payload == shard.payload {
      return Ok(Duplicate)
    }
    return Err(ConflictingIdentity)
  }
  let epoch = shard.timestamp / self.window.width
  if epoch <= self.window.latest - self.window.slots.length().to_int64() {
    return Err(WindowFailure(ClockWentBackward))
  }
  let expired = self.expired(epoch)
  if self.seen.length() - expired.length() >= self.capacity {
    return Err(IdentityBudget)
  }
  let histogram = match shard.decoded {
    Some(value) => value
    None =>
      match Histogram::from_snapshot(shard.payload) {
        Err(error) => return Err(ShardFailure(InvalidHistogram(error)))
        Ok(value) => value
      }
  }
  match self.window.merge_live_epoch(epoch, histogram) {
    Err(error) => return Err(WindowFailure(error))
    Ok(_) => ()
  }
  for old in expired {
    self.seen.remove(old)
  }
  self.seen[id] = { ..shard, decoded: None, }
  Ok(Added)
}

///|
pub fn Collector::receive_bytes(
  self : Collector,
  bytes : Bytes,
) -> Result[Receipt, CollectError] {
  match Shard::decode(bytes) {
    Err(error) => Err(ShardFailure(error))
    Ok(shard) => self.receive(shard)
  }
}

///|
pub fn Collector::advance(
  self : Collector,
  timestamp : Int64,
) -> Result[Unit, CollectError] {
  let expired = self.expired(timestamp / self.window.width)
  match self.window.advance(timestamp) {
    Err(error) => return Err(WindowFailure(error))
    Ok(_) => ()
  }
  for old in expired {
    self.seen.remove(old)
  }
  Ok(())
}

///|
pub fn Collector::summary(self : Collector) -> Histogram {
  self.window.summary()
}