///|
/// An epoch is an identity-bearing mutable cell. Freezing a root also freezes
/// pages owned by that epoch; the next writer takes a fresh one.
priv struct RowEpoch {
  mut shared : Bool
}

///|
priv struct RowPage {
  epoch : RowEpoch
  rows : Array[StoredRow?]
}

///|
/// Stable physical slots, ordered iteration and bounded page copy-on-write.
/// Only roots/epochs are forked. All persistent metadata stays out of images.
priv struct RowPages {
  mut pages : @rowvector.Vector[RowPage]
  mut epoch : RowEpoch
  mut count : Int32
  mut used : Int32
}

///|
fn row_pages(rows : Array[StoredRow]) -> RowPages {
  let epoch = { shared: false, }
  let pages : Array[RowPage] = []
  let mut start = 0
  while start < rows.length() {
    let offset = start
    pages.push({
      epoch,
      rows: Array::makei((rows.length() - start).min(64), i => {
        Some(rows[offset + i])
      }),
    })
    start += 64
  }
  {
    pages: @rowvector.Vector(pages[:]),
    epoch,
    count: rows.length(),
    used: rows.length(),
  }
}

///|
fn RowPages::fork(self : RowPages) -> RowPages {
  self.epoch.shared = true
  { ..self, epoch: { shared: false, }, }
}

///|
fn RowPages::length(self : RowPages) -> Int32 {
  self.count
}

///|
fn RowPages::is_empty(self : RowPages) -> Bool {
  self.count == 0
}

///|
fn RowPages::get_slot(self : RowPages, slot : Int32) -> StoredRow? {
  if slot < 0 || slot >= self.used {
    None
  } else {
    self.pages[slot / 64].rows[slot % 64]
  }
}

///|
/// Logical indexing is needed only at compatibility/DDL boundaries. Point
/// lookup and mutation use stable slots, never dense ordinal positions.
#alias("_[_]")
fn RowPages::at(self : RowPages, index : Int32) -> StoredRow {
  guard index >= 0 && index < self.count else {
    abort("row index out of bounds")
  }
  if self.count == self.used {
    return self.get_slot(index).unwrap()
  }
  let mut logical = 0
  for page in self.pages {
    for row in page.rows {
      if row is Some(row) {
        if logical == index {
          return row
        }
        logical += 1
      }
    }
  }
  abort("row count mismatch")
}

///|
fn RowPages::own_page(self : RowPages, index : Int32) -> RowPage {
  if self.epoch.shared {
    self.epoch = { shared: false, }
  }
  let previous = self.pages[index]
  if physical_equal(previous.epoch, self.epoch) {
    return previous
  }
  let page = { epoch: self.epoch, rows: previous.rows.copy(), }
  self.pages = self.pages.set(index, page)
  page
}

///|
fn RowPages::push(self : RowPages, row : StoredRow) -> Unit {
  if self.epoch.shared {
    self.epoch = { shared: false, }
  }
  if self.used % 64 == 0 {
    self.pages = self.pages.push({ epoch: self.epoch, rows: [Some(row)], })
  } else {
    self.own_page(self.used / 64).rows.push(Some(row))
  }
  self.count += 1
  self.used += 1
}

///|
fn RowPages::set_slot(self : RowPages, slot : Int32, row : StoredRow) -> Unit {
  guard self.get_slot(slot) is Some(_) else { abort("missing row slot") }
  self.own_page(slot / 64).rows[slot % 64] = Some(row)
}

///|
/// Deletion leaves other physical slots unchanged. Occasionally repack after
/// at least half the slots are empty; this bounds tombstones, amortizing O(N).
fn RowPages::remove_slot(self : RowPages, slot : Int32) -> Bool {
  guard self.get_slot(slot) is Some(_) else { abort("missing row slot") }
  self.own_page(slot / 64).rows[slot % 64] = None
  self.count -= 1
  if self.count == 0 || (self.used > 128 && self.used > self.count * 2) {
    let packed = row_pages(self.copy())
    self.pages = packed.pages
    self.epoch = packed.epoch
    self.used = packed.used
    return true
  }
  false
}

///|
/// Iterators retain the old page root, even when a callback mutates this table.
fn RowPages::cursor(self : RowPages) -> RowCursor {
  self.epoch.shared = true
  { pages: self.pages, page: 0, offset: 0, }
}

///|
priv struct RowCursor {
  pages : @rowvector.Vector[RowPage]
  mut page : Int32
  mut offset : Int32
}

///|
fn RowCursor::next(self : RowCursor) -> StoredRow? {
  while self.page < self.pages.length() {
    let page = self.pages[self.page]
    if self.offset >= page.rows.length() {
      self.page += 1
      self.offset = 0
      continue
    }
    let row = page.rows[self.offset]
    self.offset += 1
    if row is Some(row) {
      return Some(row)
    }
  }
  None
}

///|
fn RowPages::slot_entries(self : RowPages) -> Iter[(Int32, StoredRow)] {
  let cursor = self.cursor()
  Iter::new(fn() {
    cursor.next().map(row => (cursor.page * 64 + cursor.offset - 1, row))
  })
}

///|
fn RowPages::iter(self : RowPages) -> Iter[StoredRow] {
  let cursor = self.cursor()
  Iter::new(fn() { cursor.next() })
}

///|
fn RowPages::copy(self : RowPages) -> Array[StoredRow] {
  self.iter().collect()
}

///|
fn[T] RowPages::map(
  self : RowPages,
  f : (StoredRow) -> T raise?,
) -> Array[T] raise? {
  let result : Array[T] = []
  for row in self.iter() {
    result.push(f(row))
  }
  result
}

///|
fn RowPages::filter(
  self : RowPages,
  f : (StoredRow) -> Bool raise?,
) -> Array[StoredRow] raise? {
  let result : Array[StoredRow] = []
  for row in self.iter() {
    if f(row) {
      result.push(row)
    }
  }
  result
}

///|
fn RowPages::any(
  self : RowPages,
  f : (StoredRow) -> Bool raise?,
) -> Bool raise? {
  for row in self.iter() {
    if f(row) {
      return true
    }
  }
  false
}

///|
impl @json.ToJson for RowPages with fn to_json(self) {
  Json::array(self.map(row => @json.to_json(row)))
}

///|
impl @json.FromJson for RowPages with fn from_json(json, path) {
  row_pages(@json.from_json(json, path~))
}