///|
fn Writer::markdown_text(self : Writer, text : String) -> Unit {
  for c in text.iter() {
    if self.failed {
      return
    }
    match c {
      '&' => self.write("&")
      '<' => self.write("<")
      '>' => self.write(">")
      '\\'
      | '`'
      | '*'
      | '_'
      | '['
      | ']'
      | '#'
      | '!'
      | '|'
      | '+'
      | '-'
      | '.'
      | '('
      | ')' => {
        self.write("\\")
        self.write(c.to_string())
      }
      '\n' => self.write("  \n")
      _ => self.write(c.to_string())
    }
  }
}

///|
fn fence_for(text : String) -> String {
  let mut longest = 2
  let mut current = 0
  for c in text.iter() {
    if c == '`' {
      current = current + 1
      if current > longest {
        longest = current
      }
    } else {
      current = 0
    }
  }
  let out = StringBuilder()
  for i = 0; i <= longest; i = i + 1 {
    out.write_char('`')
  }
  out.to_string()
}

///|
fn Writer::markdown_run(self : Writer, run : Inline) -> Unit {
  let chars = run.text.to_array()
  let mut start = 0
  let mut end = chars.length()
  while start < end &&
        (chars[start] == ' ' || chars[start] == '\n' || chars[start] == '\t') {
    start = start + 1
  }
  while end > start &&
        (
          chars[end - 1] == ' ' ||
          chars[end - 1] == '\n' ||
          chars[end - 1] == '\t'
        ) {
    end = end - 1
  }
  self.markdown_text(chars_string(chars, 0, start))
  if end > start {
    let marker = match run.font {
      Bold => "**"
      Italic => "*"
      _ => ""
    }
    self.write(marker)
    self.markdown_text(chars_string(chars, start, end))
    self.write(marker)
  }
  self.markdown_text(chars_string(chars, end, chars.length()))
}

///|
fn Writer::markdown_inlines(self : Writer, runs : Array[Inline]) -> Unit {
  let mut active : String? = None
  for run in runs {
    let target = match run.target {
      Some(value) if safe_target(value) => Some(value)
      _ => None
    }
    if active != target {
      if active is Some(value) {
        self.write("](<")
        self.html_text(value)
        self.write(">)")
      }
      if target is Some(_) {
        self.write("[")
      }
      active = target
    }
    self.markdown_run(run)
    if self.failed {
      return
    }
  }
  if active is Some(value) {
    self.write("](<")
    self.html_text(value)
    self.write(">)")
  }
}

///|
/// Conservative CommonMark: escaped prose, fenced literal blocks, safe links.
/// Code font within prose falls back to plain text to avoid delimiter ambiguity.
pub fn render_markdown(
  doc : Document,
  options~ : RenderOptions = RenderOptions::default(),
) -> Result[String, Diagnostic] {
  if options.validate() is Some(d) {
    return Err(d)
  }
  if validate_document(doc) is Err(d) {
    return Err(d)
  }
  let writer = Writer::new(options.max_output_chars)
  if options.include_title && doc.metadata.title != "" {
    writer.write("# ")
    writer.markdown_text(doc.metadata.title)
    if doc.metadata.section != "" {
      writer.write("(")
      writer.markdown_text(doc.metadata.section)
      writer.write(")")
    }
    writer.write("\n\n")
  }
  for block in doc.blocks {
    if writer.failed {
      break
    }
    match block.kind {
      Heading(level) => {
        writer.write(if level == 1 { "## " } else { "### " })
        writer.markdown_inlines(block.inlines)
        writer.write("\n\n")
      }
      Tagged(term) => {
        writer.markdown_inlines(term)
        writer.write("\n\n: ")
        writer.markdown_inlines(block.inlines)
        writer.write("\n\n")
      }
      Literal | Synopsis => {
        let text = inline_text(block.inlines)
        let fence = fence_for(text)
        writer.write(fence + "text\n")
        writer.write(text)
        writer.write("\n" + fence + "\n\n")
      }
      Rule => writer.write("---\n\n")
      Paragraph | Hanging(_) => {
        writer.markdown_inlines(block.inlines)
        writer.write("\n\n")
      }
    }
  }
  writer.finish()
}