///|
/// Explicit ceilings bound parser, compiler, reference and live monitor work.
pub struct Limits {
  priv nodes : Int32
  priv depth : Int32
  priv candidates : Int32
  priv events : Int32
}

///|
pub fn Limits::new(
  nodes~ : Int32 = 512,
  depth~ : Int32 = 64,
  candidates~ : Int32 = 65536,
  events~ : Int32 = 1000000,
) -> Result[Limits, MonitorError] {
  if nodes < 1 ||
    nodes > 4096 ||
    depth < 1 ||
    depth > 128 ||
    candidates < 1 ||
    candidates > 1000000 ||
    events < 1 ||
    events > 1000000000 {
    return Err(
      ResourceLimit(
        "invalid limits: nodes<=4096, depth<=128, candidates<=1000000, events<=1000000000",
      ),
    )
  }
  Ok({ nodes, depth, candidates, events, })
}

///|
pub fn Limits::defaults() -> Limits {
  Limits::new().unwrap()
}

///|
pub fn Limits::max_nodes(self : Limits) -> Int32 {
  self.nodes
}

///|
pub fn Limits::max_depth(self : Limits) -> Int32 {
  self.depth
}

///|
pub fn Limits::max_candidates(self : Limits) -> Int32 {
  self.candidates
}

///|
pub fn Limits::max_events(self : Limits) -> Int32 {
  self.events
}

///|
fn valid_identifier(name : String) -> Bool {
  if name.length() == 0 || name.length() > 128 {
    return false
  }
  let chars = name.to_array()
  for i in 0..= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
    if !letter && !(i > 0 && ((c >= '0' && c <= '9') || c == '.')) {
      return false
    }
  }
  true
}

///|
pub fn MonitorError::message(self : MonitorError) -> String {
  match self {
    InvalidData(reason) => "invalid data: " + reason
    InvalidInterval => "interval requires 0 <= lower <= upper"
    InvalidTimestamp(i) =>
      "timestamps must be nonnegative and strictly increasing at observation \{i}"
    MissingAtom(name, i) => "missing atom \{name} at observation \{i}"
    InvalidPosition(i) => "invalid observation position \{i}"
    ResourceLimit(reason) => "resource limit: " + reason
    SyntaxError(position, reason) =>
      "syntax error at character \{position}: " + reason
  }
}