// Port of the `ts_query_*` accessors in tree-sitter lib/src/query.c.

///|
/// `ts_query_copy`.
pub fn Query::copy(self : Query) -> Query {
  {
    captures: { names: self.captures.names.copy() },
    predicate_values: { names: self.predicate_values.names.copy() },
    capture_quantifiers: self.capture_quantifiers.map(q => q.copy()),
    steps: self.steps.map(s => s.copy()),
    pattern_map: self.pattern_map.copy(),
    predicate_steps: self.predicate_steps.copy(),
    patterns: self.patterns.map(p => { ..p }),
    step_offsets: self.step_offsets.copy(),
    negated_fields: self.negated_fields.copy(),
    string_buffer: self.string_buffer.copy(),
    repeat_symbols_with_rootless_patterns: self.repeat_symbols_with_rootless_patterns.copy(),
    language: self.language,
    wildcard_root_pattern_count: self.wildcard_root_pattern_count,
  }
}

///|
pub fn Query::language(self : Query) -> @language.Language {
  self.language
}

///|
/// `ts_query_pattern_count`.
pub fn Query::pattern_count(self : Query) -> Int {
  self.patterns.length()
}

///|
/// `ts_query_capture_count`.
pub fn Query::capture_count(self : Query) -> Int {
  self.captures.names.length()
}

///|
/// `ts_query_string_count`.
pub fn Query::string_count(self : Query) -> Int {
  self.predicate_values.names.length()
}

///|
/// `ts_query_capture_name_for_id` (the UTF-8 bytes of the name).
pub fn Query::capture_name_bytes_for_id(self : Query, index : Int) -> Bytes {
  self.captures.name_for_id(index)
}

///|
/// `ts_query_capture_name_for_id`.
pub fn Query::capture_name_for_id(self : Query, index : Int) -> String {
  @utf8.decode_lossy(self.captures.name_for_id(index))
}

///|
/// `ts_query_capture_quantifier_for_id`.
pub fn Query::capture_quantifier_for_id(
  self : Query,
  pattern_index : Int,
  capture_index : Int,
) -> Quantifier {
  capture_quantifier_for_id(
    self.capture_quantifiers[pattern_index],
    capture_index,
  )
}

///|
/// `ts_query_string_value_for_id` (the bytes of the value).
pub fn Query::string_value_bytes_for_id(self : Query, index : Int) -> Bytes {
  self.predicate_values.name_for_id(index)
}

///|
/// `ts_query_string_value_for_id`.
pub fn Query::string_value_for_id(self : Query, index : Int) -> String {
  @utf8.decode_lossy(self.predicate_values.name_for_id(index))
}

///|
/// `ts_query_predicates_for_pattern`.
pub fn Query::predicates_for_pattern(
  self : Query,
  pattern_index : Int,
) -> ArrayView[QueryPredicateStep] {
  let slice = self.patterns[pattern_index].predicate_steps
  self.predicate_steps[slice.offset:slice.offset + slice.length]
}

///|
/// `ts_query_start_byte_for_pattern`.
pub fn Query::start_byte_for_pattern(self : Query, pattern_index : Int) -> UInt {
  self.patterns[pattern_index].start_byte
}

///|
/// `ts_query_end_byte_for_pattern`.
pub fn Query::end_byte_for_pattern(self : Query, pattern_index : Int) -> UInt {
  self.patterns[pattern_index].end_byte
}

///|
/// `ts_query_is_pattern_rooted`.
pub fn Query::is_pattern_rooted(self : Query, pattern_index : Int) -> Bool {
  for entry in self.pattern_map {
    if entry.pattern_index == pattern_index {
      if !entry.is_rooted {
        return false
      }
    }
  }
  true
}

///|
/// `ts_query_is_pattern_non_local`.
pub fn Query::is_pattern_non_local(self : Query, pattern_index : Int) -> Bool {
  if pattern_index < self.patterns.length() {
    self.patterns[pattern_index].is_non_local
  } else {
    false
  }
}

///|
/// `ts_query_is_pattern_guaranteed_at_step`.
pub fn Query::is_pattern_guaranteed_at_step(
  self : Query,
  byte_offset : UInt,
) -> Bool {
  let mut step_index = -1
  for step_offset in self.step_offsets {
    if step_offset.byte_offset > byte_offset {
      break
    }
    step_index = step_offset.step_index
  }
  if step_index >= 0 && step_index < self.steps.length() {
    self.steps[step_index].root_pattern_guaranteed
  } else {
    false
  }
}

///|
/// `ts_query__step_is_fallible`.
fn Query::step_is_fallible(self : Query, step_index : Int) -> Bool {
  let mut i = 1
  let step = self.steps[step_index]
  let mut next_step = step
  for ;; {
    next_step = self.steps[step_index + i]
    i += 1
    if !next_step.is_pass_through {
      break
    }
  }
  next_step.depth != pattern_done_marker &&
  (next_step.depth > step.depth ||
  (next_step.depth == step.depth && next_step.is_immediate)) &&
  (!next_step.parent_pattern_guaranteed || step.symbol == wildcard_symbol)
}

///|
/// `ts_query_disable_capture`.
pub fn Query::disable_capture(self : Query, name : StringView) -> Unit {
  // Remove capture information for any pattern step that previously captured
  // with the given name.
  let id = self.captures.id_for_name(@utf8.encode(name))
  if id != -1 {
    for step in self.steps {
      step.remove_capture(id)
    }
  }
}

///|
/// `ts_query_disable_pattern`.
pub fn Query::disable_pattern(self : Query, pattern_index : Int) -> Unit {
  // Remove the given pattern from the pattern map. Its steps will still be
  // in the `steps` array, but they will never be read.
  let mut i = 0
  while i < self.pattern_map.length() {
    if self.pattern_map[i].pattern_index == pattern_index {
      ignore(self.pattern_map.remove(i))
    } else {
      i += 1
    }
  }
}