///|
fn visible_length(text : String, remaining : Int32) -> Int32? {
  let mut count = 0
  for c in text.iter() {
    if c.is_control() && c != '\n' && c != '\t' {
      return None
    }
    count = count + 1
    if count > remaining {
      return None
    }
  }
  Some(count)
}

///| Validate a caller-built AST as well as parsed documents, before rendering.

///|
/// Validation neither edits the document nor treats parser warnings as fatal.
pub fn validate_document(
  doc : Document,
  limits~ : Options = Options::default(),
) -> Result[Unit, Diagnostic] {
  if limits.validate() is Some(d) {
    return Err(d)
  }
  if doc.blocks.length() > limits.max_blocks {
    return Err(
      diagnostic("block-limit", "AST exceeds max_blocks", 1, severity=Error),
    )
  }
  let mut remaining = limits.max_chars
  for
    field in [
      doc.metadata.title,
      doc.metadata.section,
      doc.metadata.date,
      doc.metadata.source,
      doc.metadata.manual,
    ] {
    match visible_length(field, remaining) {
      Some(count) => remaining = remaining - count
      None =>
        return Err(
          diagnostic(
            "invalid-metadata",
            "Metadata contains controls or exceeds text budget",
            1,
            severity=Error,
          ),
        )
    }
  }
  let mut nodes = 0
  for block in doc.blocks {
    let line = block.span.line
    if line < 1 ||
      block.span.column < 1 ||
      block.span.end_line < line ||
      block.span.end_column < 1 {
      return Err(
        diagnostic(
          "invalid-span",
          "AST source span is invalid",
          1,
          severity=Error,
        ),
      )
    }
    if block.indent < 0 || block.indent > limits.max_indent {
      return Err(
        diagnostic(
          "invalid-indent",
          "AST margin is outside max_indent",
          line,
          severity=Error,
        ),
      )
    }
    match block.kind {
      Heading(level) if level != 1 && level != 2 =>
        return Err(
          diagnostic(
            "invalid-heading",
            "Heading level must be 1 or 2",
            line,
            severity=Error,
          ),
        )
      Hanging(width) if width < 0 || width > limits.max_indent =>
        return Err(
          diagnostic(
            "invalid-indent",
            "Hanging width is outside max_indent",
            line,
            severity=Error,
          ),
        )
      _ => ()
    }
    let groups = match block.kind {
      Tagged(term) => [term, block.inlines]
      _ => [block.inlines]
    }
    for runs in groups {
      if runs.length() > limits.max_inlines - nodes {
        return Err(
          diagnostic(
            "node-limit",
            "AST exceeds max_inlines",
            line,
            severity=Error,
          ),
        )
      }
      nodes = nodes + runs.length()
      for run in runs {
        match visible_length(run.text, remaining) {
          Some(count) => remaining = remaining - count
          None =>
            return Err(
              diagnostic(
                "invalid-text",
                "AST text contains controls or exceeds text budget",
                line,
                severity=Error,
              ),
            )
        }
        if run.target is Some(target) {
          match visible_length(target, remaining) {
            Some(count) => remaining = remaining - count
            None =>
              return Err(
                diagnostic(
                  "invalid-target",
                  "Link target contains controls or exceeds text budget",
                  line,
                  severity=Error,
                ),
              )
          }
        }
      }
    }
  }
  Ok(())
}