///|
priv suberror RepairFault {
  Fault(RepairError)
}

///|
priv struct Cursor {
  input : StringView
  mut limit : Int32
  mut offset : Int32
  mut line : Int32
  mut column : Int32
  mut after_cr : Bool
  edits : Array[RepairEdit]
  limits : RepairLimits
  json5 : Bool
  mut seals : SealTrace?
}

///|
fn Cursor::new(
  input : StringView,
  limits : RepairLimits,
  json5~ : Bool = false,
) -> Cursor {
  {
    input,
    limit: input.length(),
    offset: 0,
    line: 1,
    column: 1,
    after_cr: false,
    edits: [],
    limits,
    json5,
    seals: None,
  }
}

///|
fn Cursor::position(self : Cursor) -> SourcePosition {
  { offset: self.offset, line: self.line, column: self.column, }
}

///|
fn Cursor::peek(self : Cursor, ahead~ : Int32 = 0) -> Char {
  let offset = self.offset + ahead
  if offset >= self.limit {
    '\u{FFFF}'
  } else {
    char_at(self.input, offset)
  }
}

///|
fn Cursor::at_end(self : Cursor) -> Bool {
  self.offset >= self.limit
}

///|
fn Cursor::bump(self : Cursor) -> Unit {
  self.consume(self.peek())
}

///|
fn Cursor::consume(self : Cursor, c : Char) -> Unit {
  self.offset += 1
  match c {
    '\r' => {
      self.line += 1
      self.column = 1
    }
    '\n' => {
      if !self.after_cr {
        self.line += 1
      }
      self.column = 1
    }
    _ => self.column += 1
  }
  self.after_cr = c == '\r'
}

///|
fn Cursor::advance(self : Cursor, offset : Int32) -> Unit {
  while self.offset < offset {
    self.bump()
  }
}

///|
fn Cursor::span(self : Cursor, start : Int32, end : Int32) -> StringView {
  self.input.exact_view(start~, end~)
}

///|
fn Cursor::starts(self : Cursor, token : StringView) -> Bool {
  let start = self.offset
  start + token.length() <= self.limit && units_match(self.input, start, token)
}

///|
fn units_match(input : StringView, start : Int32, token : StringView) -> Bool {
  if start + token.length() > input.length() {
    return false
  }
  for i in 0.. Unit raise RepairFault {
  raise Fault({ kind, message, position: at.unwrap_or(self.position()), })
}

///|
fn Cursor::edit(
  self : Cursor,
  kind : RepairKind,
  action : String,
  position : SourcePosition,
  replacement~ : String = "",
  end_offset? : Int32,
) -> Unit raise RepairFault {
  if self.edits.length() >= self.limits.max_edits {
    self.reject(EditLimit, "repair edit limit exceeded", at=position)
  }
  self.edits.push({
    kind,
    action,
    position,
    end_offset: end_offset.unwrap_or(self.offset),
    replacement,
  })
}

///|
fn is_json_space(c : Char) -> Bool {
  c is (' ' | '\t' | '\r' | '\n')
}

///|
fn is_identifier_start(c : Char) -> Bool {
  c.is_ascii_alphabetic() || c is ('_' | '$')
}

///|
fn is_identifier_continue(c : Char) -> Bool {
  is_identifier_start(c) || c.is_ascii_digit() || c == '-'
}

///|
fn Cursor::skip_trivia(self : Cursor) -> Unit raise RepairFault {
  while !self.at_end() {
    let c = self.peek()
    if is_json_space(c) {
      self.consume(c)
    } else if self.starts("//") {
      let at = self.position()
      self.advance(at.offset + 2)
      while !self.at_end() && !(self.peek() is ('\r' | '\n')) {
        self.bump()
      }
      self.edit(RemoveComment, "remove line comment", at)
    } else if self.starts("/*") {
      let at = self.position()
      self.advance(at.offset + 2)
      while !self.at_end() && !self.starts("*/") {
        self.bump()
      }
      if !self.at_end() {
        self.advance(self.offset + 2)
      }
      self.edit(RemoveComment, "remove block comment", at)
    } else {
      break
    }
  }
}

///|
fn control_escape(c : Char) -> String {
  match c {
    '\n' => "\\n"
    '\r' => "\\r"
    '\t' => "\\t"
    '\u0008' => "\\b"
    '\u000C' => "\\f"
    _ => {
      let hex = "0123456789abcdef"
      let code = c.to_int()
      let high = hex[code / 16].to_int().unsafe_to_char()
      let low = hex[code % 16].to_int().unsafe_to_char()
      "\\u00\{high}\{low}"
    }
  }
}

///|
fn Cursor::unicode_escape_at(self : Cursor, offset : Int32) -> Int32 {
  if self.peek(ahead=offset) != 'u' {
    return -1
  }
  let mut unit = 0
  for i in 1..<=4 {
    let c = self.peek(ahead=offset + i)
    let digit = match c {
      '0'..<='9' => c.to_int() - '0'.to_int()
      'a'..<='f' => c.to_int() - 'a'.to_int() + 10
      'A'..<='F' => c.to_int() - 'A'.to_int() + 10
      _ => return -1
    }
    unit = unit * 16 + digit
  }
  unit
}

///|
fn Cursor::read_escape(
  self : Cursor,
  quote : Char,
  out : StringBuilder,
) -> Unit raise RepairFault {
  let at = self.position()
  self.bump()
  let valid = match self.peek() {
    '"' | '\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' => 1
    'u' => {
      let unit = self.unicode_escape_at(0)
      if unit < 0 || (unit >= 0xDC00 && unit <= 0xDFFF) {
        0
      } else if unit >= 0xD800 && unit <= 0xDBFF {
        let low = self.unicode_escape_at(6)
        if self.peek(ahead=5) == '\\' && low >= 0xDC00 && low <= 0xDFFF {
          11
        } else {
          0
        }
      } else {
        5
      }
    }
    _ => 0
  }
  if valid > 0 {
    self.advance(self.offset + valid)
    out.write_view(self.span(at.offset, self.offset))
  } else if quote == '\'' && self.peek() == '\'' {
    self.bump()
    out.write_char('\'')
    self.edit(
      NormalizeQuote,
      "unescape apostrophe inside converted string",
      at,
      replacement="'",
    )
  } else {
    out.write_string("\\\\")
    self.edit(
      EscapeBackslash,
      "preserve incomplete, unpaired, or unknown escape as text",
      at,
      replacement="\\\\",
    )
  }
}

///|
fn Cursor::read_string(
  self : Cursor,
  out : StringBuilder,
) -> Unit raise RepairFault {
  ignore(self.copy_string(out))
}

///|
// True means the original source interior is already the decoded value.
fn Cursor::copy_string(
  self : Cursor,
  out : StringBuilder,
) -> Bool raise RepairFault {
  let quote = self.peek()
  let start = self.offset
  let mut chunk = start
  if quote == '\'' {
    let open = self.position()
    self.consume(quote)
    out.write_char('"')
    self.edit(
      NormalizeQuote,
      "replace opening apostrophe",
      open,
      replacement="\"",
    )
    chunk = self.offset
  } else {
    self.consume(quote)
  }
  let delimiter = quote.to_int()
  while !self.at_end() {
    let mut end = self.offset
    while end < self.limit {
      let code = self.input[end].to_int()
      if code < 32 || code == 34 || code == 92 || code == delimiter {
        break
      }
      end += 1
    }
    self.advance_plain(end)
    if self.at_end() {
      break
    }
    let c = self.peek()
    if c == quote {
      if quote == '\'' {
        let close = self.position()
        out.write_view(self.span(chunk, close.offset))
        self.consume(c)
        out.write_char('"')
        self.edit(
          NormalizeQuote,
          "replace closing apostrophe",
          close,
          replacement="\"",
        )
      } else {
        self.consume(c)
        out.write_view(self.span(chunk, self.offset))
        return chunk == start
      }
      return false
    }
    let at = self.position()
    out.write_view(self.span(chunk, at.offset))
    if c == '\\' {
      self.read_escape(quote, out)
    } else {
      self.consume(c)
      let replacement = if c == '"' { "\\\"" } else { control_escape(c) }
      out.write_string(replacement)
      if c == '"' {
        self.edit(
          NormalizeQuote,
          "escape double quote inside converted string",
          at,
          replacement~,
        )
      } else {
        self.edit(
          EscapeControl,
          "escape raw control character",
          at,
          replacement~,
        )
      }
    }
    chunk = self.offset
  }
  out.write_view(self.span(chunk, self.offset))
  out.write_char('"')
  self.edit(
    CloseString,
    "close truncated string",
    self.position(),
    replacement="\"",
  )
  false
}

///|
fn Cursor::read_key(
  self : Cursor,
  out : StringBuilder,
) -> String? raise RepairFault {
  if self.peek() is ('"' | '\'') {
    let start = self.offset
    let plain = self.copy_string(out)
    return if plain {
      Some(self.span(start + 1, self.offset - 1).to_owned())
    } else {
      None
    }
  }
  let at = self.position()
  if !is_identifier_start(self.peek()) {
    self.reject(UnexpectedToken, "expected an object key")
  }
  self.bump()
  while is_identifier_continue(self.peek()) {
    self.bump()
  }
  let key = self.span(at.offset, self.offset)
  out.write_char('"')
  out.write_view(key)
  out.write_char('"')
  self.edit(QuoteKey, "quote bare object key", at, replacement="\"\{key}\"")
  Some(key.to_owned())
}

///|
// Update coordinates once for a run the caller has already proven has no CR/LF.
fn Cursor::advance_plain(self : Cursor, end : Int32) -> Unit {
  if end > self.offset {
    self.column += end - self.offset
    self.offset = end
    self.after_cr = false
  }
}

///|
fn Cursor::digits(self : Cursor) -> Unit {
  let mut end = self.offset
  while end < self.limit {
    let code = self.input[end].to_int()
    if code < 48 || code > 57 {
      break
    }
    end += 1
  }
  self.advance_plain(end)
}

///|
fn hex_digit(c : Char) -> Int32 {
  match c {
    '0'..<='9' => c.to_int() - '0'.to_int()
    'a'..<='f' => c.to_int() - 'a'.to_int() + 10
    'A'..<='F' => c.to_int() - 'A'.to_int() + 10
    _ => -1
  }
}

///|
// Multiplication by 256 stays within Int32 for base 1,000,000 limbs.
// At most 1,024 hex digits enter conversion, bounding its quadratic work.
fn decimal_from_hex(digits : StringView, negative : Bool) -> String {
  let limbs = [0]
  let base = 1_000_000
  let mut offset = 0
  while offset < digits.length() {
    let mut count = 2
    if digits.length() - offset == 1 {
      count = 1
    }
    let mut carry = 0
    for i in offset..<(offset + count) {
      carry = carry * 16 + hex_digit(char_at(digits, i))
    }
    let multiplier = if count == 2 { 256 } else { 16 }
    for i in 0.. 0 {
    index -= 1
    let digits = limbs[index].to_string()
    for _ in digits.length()..<6 {
      out.write_char('0')
    }
    out.write_string(digits)
  }
  out.to_string()
}

///|
fn invalid_number_suffix(c : Char) -> Bool {
  is_identifier_start(c) || c is ('.' | '-' | '+')
}

///|
fn Cursor::read_hex_number(
  self : Cursor,
  out : StringBuilder,
  at : SourcePosition,
  negative : Bool,
) -> Unit raise RepairFault {
  self.advance(self.offset + 2)
  let start = self.offset
  while hex_digit(self.peek()) >= 0 {
    self.bump()
    if self.offset - start > 1024 {
      self.reject(InvalidNumber, "hexadecimal integer exceeds 1024 digits", at~)
    }
  }
  if start == self.offset || invalid_number_suffix(self.peek()) {
    self.reject(InvalidNumber, "invalid hexadecimal integer", at~)
  }
  let replacement = decimal_from_hex(self.span(start, self.offset), negative)
  out.write_string(replacement)
  self.edit(
    NormalizeLiteral,
    "convert hexadecimal integer to decimal",
    at,
    replacement~,
  )
}

///|
fn Cursor::read_number(
  self : Cursor,
  out : StringBuilder,
) -> Unit raise RepairFault {
  let at = self.position()
  let sign = self.peek()
  if sign == '-' || (self.json5 && sign == '+') {
    self.bump()
  }
  if self.json5 && self.peek() == '0' && self.peek(ahead=1) is ('x' | 'X') {
    self.read_hex_number(out, at, sign == '-')
    return
  }
  let digits_start = self.offset
  let leading_dot = self.json5 && self.peek() == '.'
  if !leading_dot {
    match self.peek() {
      '0' => {
        self.bump()
        if self.peek().is_ascii_digit() {
          self.reject(InvalidNumber, "leading zero in number", at~)
        }
      }
      '1'..<='9' => self.digits()
      _ => self.reject(InvalidNumber, "expected a digit", at~)
    }
  }
  let mut trailing_dot = false
  if self.peek() == '.' {
    self.bump()
    if !self.peek().is_ascii_digit() {
      if !self.json5 || leading_dot {
        self.reject(InvalidNumber, "expected a fractional digit", at~)
      }
      trailing_dot = true
    } else {
      self.digits()
    }
  }
  let exponent_start = self.offset
  if self.peek() is ('e' | 'E') {
    self.bump()
    if self.peek() is ('+' | '-') {
      self.bump()
    }
    if !self.peek().is_ascii_digit() {
      self.reject(InvalidNumber, "expected an exponent digit", at~)
    }
    self.digits()
  }
  if invalid_number_suffix(self.peek()) {
    self.reject(InvalidNumber, "invalid character following number", at~)
  }
  if self.json5 && (sign == '+' || leading_dot || trailing_dot) {
    let normalized = StringBuilder()
    if sign == '-' {
      normalized.write_char('-')
    }
    if leading_dot {
      normalized.write_char('0')
    }
    normalized.write_view(self.span(digits_start, exponent_start))
    if trailing_dot {
      normalized.write_char('0')
    }
    normalized.write_view(self.span(exponent_start, self.offset))
    let replacement = normalized.to_string()
    out.write_string(replacement)
    self.edit(
      NormalizeLiteral,
      "normalize JSON5 decimal number",
      at,
      replacement~,
    )
  } else {
    out.write_view(self.span(at.offset, self.offset))
  }
}

///|
fn Cursor::read_literal(
  self : Cursor,
  out : StringBuilder,
) -> Unit raise RepairFault {
  let at = self.position()
  while is_identifier_continue(self.peek()) {
    self.bump()
  }
  let word = self.span(at.offset, self.offset)
  let replacement = match word {
    "true" | "false" | "null" => {
      out.write_view(word)
      return
    }
    "True" => "true"
    "False" => "false"
    "None" | "undefined" => "null"
    _ => {
      if self.at_end() {
        if literal_completion(word) is Some(text) {
          out.write_string(text)
          self.edit(
            CompleteLiteral,
            "complete a truncated JSON literal",
            at,
            replacement=text,
          )
          return
        }
      }
      self.reject(UnexpectedToken, "unrecognized JSON literal", at~)
      return
    }
  }
  out.write_string(replacement)
  self.edit(NormalizeLiteral, "convert non-JSON literal", at, replacement~)
}

///|
fn literal_completion(word : StringView) -> String? {
  match char_at(word, 0) {
    't' => complete_literal(word, "true", "true")
    'f' => complete_literal(word, "false", "false")
    'n' => complete_literal(word, "null", "null")
    'T' => complete_literal(word, "True", "true")
    'F' => complete_literal(word, "False", "false")
    'N' => complete_literal(word, "None", "null")
    'u' => complete_literal(word, "undefined", "null")
    _ => None
  }
}

///|
fn complete_literal(
  prefix : StringView,
  spelling : StringView,
  normalized : String,
) -> String? {
  if spelling.has_prefix(prefix) {
    Some(normalized)
  } else {
    None
  }
}