///|
/// Deterministic materialized edits, not SQL replay. Version 2 adds column
/// patches; version 1 after-images remain readable. Preserve publication order.
#derive(ToJson, FromJson)
priv enum RowEdit {
  AppendRow(String, StoredRow)
  ReplaceRow(String, Int64, StoredRow)
  DeleteRow(String, Int64)
  PatchRow(String, Int64, Int64, Array[(Int32, Value)])
}

///|
priv struct DirtyState {
  mut full : Bool
  base : Int32
  edits : Array[RowEdit]
}

///|
fn dirty_state() -> DirtyState {
  { full: true, base: 0, edits: [], }
}

///|
fn dirty_snapshot(store : Store) -> Unit {
  store.dirty.full = true
  store.dirty.edits.clear()
}

///|
fn dirty_edit(store : Store, edit : RowEdit) -> Unit {
  if !store.dirty.full {
    if store.dirty.edits.length() >= 4096 {
      dirty_snapshot(store)
    } else {
      store.dirty.edits.push(edit)
    }
  }
}

///|
/// Storage equality must not use SQL comparison/affinity, or merge +0 / -0.
/// Unchanged TEXT/BLOB values usually share the immutable Value object.
fn same_stored_value(before : Value, after : Value) -> Bool {
  if physical_equal(before, after) {
    return true
  }
  match (before, after) {
    (Real(a), Real(b)) => a.reinterpret_as_uint64() == b.reinterpret_as_uint64()
    _ => before == after
  }
}

///|
/// Capture at row replacement, without dumping/diffing the database or keeping
/// the previous row alive. Published patch arrays and row values are immutable.
fn dirty_replace(
  store : Store,
  name : String,
  before : StoredRow,
  after : StoredRow,
) -> Unit {
  if store.dirty.full {
    return
  }
  if store.dirty.edits.length() >= 4096 {
    dirty_snapshot(store)
    return
  }
  let columns : Array[(Int32, Value)] = []
  for i, value in after.values {
    if !same_stored_value(before.values[i], value) {
      columns.push((i, value))
    }
  }
  if columns.is_empty() && before.id == after.id {
    return
  }
  // A complete replacement is more compact when every column changed.
  dirty_edit(
    store,
    if columns.length() == after.values.length() {
      ReplaceRow(name, before.id, after)
    } else {
      PatchRow(name, before.id, after.id, columns)
    },
  )
}

///|
#derive(ToJson, FromJson)
priv struct FlushMetadata {
  encoding : Int32?
  cookie : Int32
  changes : Int32
  last_rowid : Int64
  foreign_keys : Bool
  deferred : Bool
  sequences : Array[(String, Int64, Bool?)]
}

///|
pub fn database_delta(db : Database, force_snapshot : Bool) -> String {
  let store = db.store
  if force_snapshot || store.dirty.full {
    (
      {
        "format": "sqlike-flush@1",
        "full": true,
        "serial": db.serial,
        "state": @json.to_json(store),
      } : Json).stringify()
  } else {
    let meta : FlushMetadata = {
      encoding: store.encoding,
      cookie: store.cookie,
      changes: store.changes,
      last_rowid: store.last_rowid,
      foreign_keys: store.foreign_keys,
      deferred: store.deferred,
      sequences: store.tables.map(t => (t.name, t.sequence, t.sequence_present)),
    }
    (
      {
        "format": "sqlike-flush@2",
        "full": false,
        "base": store.dirty.base,
        "serial": db.serial,
        "meta": @json.to_json(meta),
        "edits": @json.to_json(store.dirty.edits),
      } : Json).stringify()
  }
}

///|
/// The host calls this only after durable ACK, or after opening a known image.
pub fn database_ack_delta(db : Database, serial : Int32) -> String {
  if serial < 0 || serial != db.serial {
    return ({ "error": "stale flush acknowledgement" } : Json).stringify()
  }
  db.store.dirty = { full: false, base: serial, edits: [], }
  "{}"
}

///|
fn flush_row(
  store : Store,
  table : Table,
  row : StoredRow,
  except : Int64?,
) -> Unit raise SqlError {
  let ipk = integer_primary(table)
  guard row.values.length() == table.columns.length() &&
    (ipk < 0 || row.values[ipk] == Integer(row.id)) else {
    fail("invalid flush row")
  }
  for value in row.values {
    if value is Real(n) && n.is_nan() {
      fail("invalid flush real")
    }
  }
  guard table_row_by_id(store, table, row.id).filter(r => Some(r.id) != except)
    is None else {
    fail("duplicate flush rowid")
  }
  check_row(store, table, row.values, [])
  guard conflict_row(store, table, row.values, except, None) is None else {
    fail("flush UNIQUE constraint failed")
  }
}

///|
fn decode_flush(db : Database, text : String) -> (Store, Int32, Bool) raise {
  guard text.length() <= 67108864 else { fail("flush resource limit") }
  let json = @json.parse(text)
  guard json
    is { "format": String(format), "serial": serial, "full": is_full, .. } &&
    (format == "sqlike-flush@1" || format == "sqlike-flush@2") else {
    fail("invalid flush format")
  }
  let serial = flush_integer(serial)
  let full : Bool = @json.from_json(is_full)
  guard serial >= 0 else { fail("invalid flush serial") }
  if full {
    guard format == "sqlike-flush@1" else {
      fail("invalid flush snapshot version")
    }
    guard json is { "state": state, .. } else { fail("missing flush snapshot") }
    let store : Store = @json.from_json(state)
    return (store, serial, true)
  }
  guard json is { "base": base, "meta": meta, "edits": edits, .. } else {
    fail("invalid flush delta")
  }
  let base = flush_integer(base)
  guard base == db.serial && serial > base else {
    fail("flush serial mismatch")
  }
  guard meta is { "cookie": cookie, "changes": changes, .. } else {
    fail("invalid flush metadata")
  }
  ignore(flush_integer(cookie))
  ignore(flush_integer(changes))
  let meta : FlushMetadata = @json.from_json(meta)
  guard meta.cookie == db.store.cookie &&
    meta.encoding == db.store.encoding &&
    meta.changes >= 0 &&
    !meta.deferred &&
    meta.sequences.length() == db.store.tables.length() else {
    fail("flush metadata mismatch")
  }
  // FromJson[Int32] truncates fractions. Validate wire positions before typed
  // decoding so a malformed index cannot silently target a different column.
  guard edits is Array(raw_edits) && raw_edits.length() <= 100000 else {
    fail("flush edit limit")
  }
  for edit in raw_edits {
    if edit is Array([String("PatchRow"), _, _, _, Array(columns)]) {
      guard format == "sqlike-flush@2" else {
        fail("invalid flush patch version")
      }
      for column in columns {
        guard column is Array([index, _]) else { fail("invalid flush column") }
        ignore(flush_integer(index))
      }
    }
  }
  let edits : Array[RowEdit] = @json.from_json(edits)
  guard edits.length() <= 100000 else { fail("flush edit limit") }
  let store = copy_store(db.store)
  store.dirty = dirty_state()
  if format != "sqlike-flush@2" &&
    edits.any(edit => edit is PatchRow(_, _, _, _)) {
    fail("invalid flush patch version")
  }
  apply_materialized_edits(store, edits)
  for i, (name, sequence, present) in meta.sequences {
    let table = store.tables[i]
    guard table.name == name else { fail("flush table mismatch") }
    table.sequence = sequence
    table.sequence_present = present
  }
  store.changes = meta.changes
  store.last_rowid = meta.last_rowid
  store.foreign_keys = meta.foreign_keys
  store.deferred = false
  validate_foreign_keys(store)
  (store, serial, false)
}

///|
fn flush_integer(value : Json) -> Int32 raise SqlError {
  guard value is Number(number, ..) &&
    number >= 0.0 &&
    number <= 2147483647.0 &&
    number.to_int().to_double() == number else {
    fail("invalid flush integer")
  }
  number.to_int()
}

///|
fn publish_flush(db : Database, store : Store, serial : Int32) -> Unit {
  store.dirty = { full: false, base: serial, edits: [], }
  db.store = store
  db.serial = serial
}

///|
pub fn database_apply_delta(db : Database, text : String) -> String {
  try {
    let (store, serial, full) = decode_flush(db, text)
    if full {
      validate_image(store)
    }
    publish_flush(db, store, serial)
    "{}"
  } catch {
    error => ({ "error": public_error(error) } : Json).stringify()
  }
}