// Port of tree-sitter lib/src/tree.h, lib/src/tree.c and lib/src/point.c.

///|
/// A `const Subtree *`: a slot in a parent's children array (or a tree's
/// root). Upstream compares these pointers to tell nodes apart, so slots are
/// compared by array identity and index.
pub(all) struct SubtreeSlot {
  array : Array[Subtree]
  index : Int32
  /// The address of the slot's owner (parent subtree or tree), used to form
  /// node ids.
  owner : Int32
}

///|
pub fn SubtreeSlot::get(self : SubtreeSlot) -> Subtree {
  self.array[self.index]
}

///|
pub fn SubtreeSlot::same(self : SubtreeSlot, other : SubtreeSlot) -> Bool {
  physical_equal(self.array, other.array) && self.index == other.index
}

///|
/// The slot of a parent's `index`th child.
pub fn Subtree::child_slot(self : Subtree, index : Int32) -> SubtreeSlot {
  let data = self.ptr()
  { array: data.children, index, owner: data.address, }
}

///|
pub struct Tree {
  /// `root`, stored in a slot so that nodes can point at it.
  priv root_slot : Array[Subtree]
  language : @language.Language
  priv included_ranges : Array[Range]
  priv address : Int32
}

///|
/// `ts_tree_new`.
pub fn Tree::new(
  root : Subtree,
  language : @language.Language,
  included_ranges : Array[Range],
) -> Tree {
  {
    root_slot: [root],
    language,
    included_ranges: included_ranges.copy(),
    address: fresh_address(),
  }
}

///|
pub fn Tree::root(self : Tree) -> Subtree {
  self.root_slot[0]
}

///|
fn Tree::root_ref(self : Tree) -> SubtreeSlot {
  { array: self.root_slot, index: 0, owner: self.address, }
}

///|
/// `ts_tree_copy`.
pub fn Tree::copy(self : Tree) -> Tree {
  self.root().retain()
  Tree::new(self.root(), self.language, self.included_ranges)
}

///|
/// `ts_tree_delete`: release this tree's reference to its syntax.
pub fn Tree::delete(self : Tree) -> Unit {
  self.root().release()
}

///|
/// `ts_tree_root_node`.
pub fn Tree::root_node(self : Tree) -> Node {
  Node::new(Some(self), Some(self.root_ref()), self.root().padding(), 0)
}

///|
/// `ts_tree_root_node_with_offset`.
pub fn Tree::root_node_with_offset(
  self : Tree,
  offset_bytes : UInt32,
  offset_extent : Point,
) -> Node {
  let offset : Length = { bytes: offset_bytes, extent: offset_extent, }
  Node::new(
    Some(self),
    Some(self.root_ref()),
    length_add(offset, self.root().padding()),
    0,
  )
}

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

///|
/// `ts_tree_edit`.
pub fn Tree::edit(self : Tree, edit : InputEdit) -> Unit {
  for i in 0.. Array[Range] {
  self.included_ranges.copy()
}

///|
fn Tree::included_ranges_ref(self : Tree) -> Array[Range] {
  self.included_ranges
}

///|
/// `ts_tree_print_dot_graph`.
pub fn Tree::print_dot_graph(self : Tree, f : Buffer) -> Unit {
  self.root().print_dot_graph(self.language, f)
}

///|
/// `ts_point_edit`.
pub fn point_edit(
  point : Point,
  byte : UInt32,
  edit : InputEdit,
) -> (Point, UInt32) {
  let mut start_byte = byte
  let mut start_point = point
  if start_byte >= edit.old_end_byte {
    start_byte = edit.new_end_byte + (start_byte - edit.old_end_byte)
    start_point = point_add(
      edit.new_end_point,
      point_sub(start_point, edit.old_end_point),
    )
  } else if start_byte > edit.start_byte {
    start_byte = edit.new_end_byte
    start_point = edit.new_end_point
  }
  (start_point, start_byte)
}