///|
// Wire v1: SQLK, version:u8, kind:u8, reserved:u16, features:u32le,
// payloadLength:u32le, string-pool + typed payload, SHA256(header + payload).
// Format ownership is independent of JSON derives and generated JS internals.
priv struct BinaryWriter {
  out : @buffer.Buffer
  strings : Array[String]
  ids : Map[String, UInt32]
  mut features : UInt32
}

///|
priv struct BinaryReader {
  bytes : BytesView
  mut position : Int32
  strings : Array[String]
  mut depth : Int32
  declared : UInt32
  mut features : UInt32
}

///|
priv trait Binary {
  fn write(Self, BinaryWriter) -> Unit raise SqlError
  fn read(BinaryReader) -> Self raise SqlError
}

///|
fn binary_writer() -> BinaryWriter {
  { out: @buffer.Buffer(), strings: [], ids: Map([]), features: 0U, }
}

///|
fn BinaryWriter::require_feature(w : BinaryWriter, flag : UInt32) -> Unit {
  w.features = w.features | flag
}

///|
fn BinaryReader::require_feature(r : BinaryReader, flag : UInt32) -> Unit {
  r.features = r.features | flag
}

///|
fn BinaryWriter::uint(w : BinaryWriter, value : UInt32) -> Unit {
  let mut n = value
  while n >= 128U {
    w.out.write_byte(((n & 127U) | 128U).to_byte())
    n = n >> 7
  }
  w.out.write_byte(n.to_byte())
}

///|
fn BinaryReader::byte(r : BinaryReader) -> Byte raise SqlError {
  guard r.position < r.bytes.length() else {
    fail("truncated binary definition")
  }
  let value = r.bytes[r.position]
  r.position += 1
  value
}

///|
fn BinaryReader::uint(r : BinaryReader) -> UInt32 raise SqlError {
  let mut value = 0U
  for i in 0..<5 {
    let b = r.byte().to_uint()
    guard i < 4 || b < 16U else { fail("binary integer overflow") }
    value = value | ((b & 127U) << (i * 7))
    if b < 128U {
      guard i == 0 || b != 0U else { fail("noncanonical binary integer") }
      return value
    }
  }
  fail("binary integer overflow")
}

///|
fn BinaryReader::length(r : BinaryReader) -> Int32 raise SqlError {
  let n = r.uint()
  guard n <= 67108864U &&
    n <= (r.bytes.length() - r.position).reinterpret_as_uint() else {
    fail("binary length resource limit")
  }
  n.reinterpret_as_int()
}

///|
fn BinaryReader::blob(r : BinaryReader) -> Bytes raise SqlError {
  let n = r.length()
  let value = r.bytes[r.position:r.position + n].to_owned()
  r.position += n
  value
}

///|
fn BinaryReader::enter(r : BinaryReader) -> Unit raise SqlError {
  guard r.depth < 256 else { fail("binary nesting resource limit") }
  r.depth += 1
}

///|
fn BinaryReader::leave(r : BinaryReader) -> Unit {
  r.depth -= 1
}

///|
fn BinaryReader::finish(r : BinaryReader) -> Unit raise SqlError {
  guard r.position == r.bytes.length() && r.features == r.declared else {
    fail("binary trailing bytes or feature mismatch")
  }
}

///|
fn binary_hex(bytes : BytesView) -> String {
  let out = StringBuilder()
  let digits = "0123456789abcdef"
  for byte in bytes {
    out.write_char(digits[byte.to_int() >> 4].to_int().unsafe_to_char())
    out.write_char(digits[byte.to_int() & 15].to_int().unsafe_to_char())
  }
  out.to_string()
}

///|
fn binary_id(bytes : Bytes) -> String {
  binary_hex(bytes[bytes.length() - 32:])
}

///|
fn binary_finish(w : BinaryWriter, kind : Int32) -> Bytes raise SqlError {
  let payload = @buffer.Buffer()
  let pool = binary_writer()
  pool.uint(w.strings.length().reinterpret_as_uint())
  payload.write_bytes(pool.out.to_bytes()[:])
  for text in w.strings {
    let bytes = @utf8.encode(text)
    guard (@utf8.decode(bytes[:]) catch { _ => "" }) == text else {
      fail("binary text must be valid UTF8")
    }
    let prefix = binary_writer()
    prefix.uint(bytes.length().reinterpret_as_uint())
    payload.write_bytes(prefix.out.to_bytes()[:])
    payload.write_bytes(bytes[:])
  }
  payload.write_bytes(w.out.to_bytes()[:])
  guard payload.length() <= 67108816 && w.strings.length() <= 100000 else {
    fail("binary output resource limit")
  }
  let out = @buffer.Buffer()
  out.write_bytes(b"SQLK"[:])
  out.write_byte(b'\x01')
  out.write_byte(kind.to_byte())
  out.write_byte(b'\x00')
  out.write_byte(b'\x00')
  out.write_uint_le(w.features)
  out.write_uint_le(payload.length().reinterpret_as_uint())
  out.write_bytes(payload.to_bytes()[:])
  out.write_iter(@crypto.sha256(out.to_bytes()).iter())
  out.to_bytes()
}

///|
fn binary_reader(
  bytes : Bytes,
  kind : Int32,
  limit : Int32,
) -> BinaryReader raise SqlError {
  guard bytes.length() >= 48 &&
    bytes.length() <= limit &&
    bytes[0:4] == b"SQLK"[:] &&
    bytes[4] == b'\x01' &&
    bytes[5].to_int() == kind &&
    bytes[6] == b'\x00' &&
    bytes[7] == b'\x00' else {
    fail("unsupported binary definition header")
  }
  let word = fn(start : Int32) {
    let mut n = 0U
    for i in 0..<4 {
      n = n | (bytes[start + i].to_uint() << (i * 8))
    }
    n
  }
  let declared = word(8)
  let allowed = (if FEATURE_SQL_JSON { 16U } else { 0U }) |
    (if FEATURE_DATETIME { 32U } else { 0U }) |
    (if FEATURE_WINDOWS { 64U } else { 0U }) |
    (if FEATURE_FOREIGN_KEYS { 1U } else { 0U }) |
    (if FEATURE_TRIGGERS { 2U } else { 0U }) |
    (if FEATURE_STRICT { 4U } else { 0U }) |
    (if FEATURE_OUTER_JOIN { 8U } else { 0U })
  guard (declared & allowed) == declared &&
    word(12) == (bytes.length() - 48).reinterpret_as_uint() else {
    fail("binary length or required feature mismatch")
  }
  let digest = @crypto.sha256(bytes[0:bytes.length() - 32])
  for i in 0..<32 {
    guard digest[i] == bytes[bytes.length() - 32 + i] else {
      fail("binary checksum mismatch")
    }
  }
  let r = {
    bytes: bytes[16:bytes.length() - 32],
    position: 0,
    strings: [],
    depth: 0,
    declared,
    features: 0U,
  }
  let count = r.length()
  guard count <= 100000 else { fail("binary string pool limit") }
  let unique : Map[String, Bool] = Map([])
  for _ in 0.. fail("invalid binary UTF8")
    }
    guard !unique.contains(text) else {
      fail("duplicate binary string pool entry")
    }
    unique[text] = true
    r.strings.push(text)
  }
  r
}

///|
impl Binary for Int32 with fn write(value, w) {
  w.uint(
    (value.reinterpret_as_uint() << 1) ^ (value >> 31).reinterpret_as_uint(),
  )
}

///|
impl Binary for Int32 with fn read(r) {
  let n = r.uint()
  let v = (n >> 1).reinterpret_as_int()
  if (n & 1U) == 1U {
    -v - 1
  } else {
    v
  }
}

///|
impl Binary for Int64 with fn write(value, w) {
  w.out.write_int64_le(value)
}

///|
impl Binary for Int64 with fn read(r) {
  let mut n = 0UL
  for i in 0..<8 {
    n = n | (r.byte().to_uint64() << (i * 8))
  }
  n.reinterpret_as_int64()
}

///|
impl Binary for Double with fn write(value, w) {
  guard !value.is_nan() else { fail("invalid binary REAL") }
  Binary::write(value.reinterpret_as_int64(), w)
}

///|
impl Binary for Double with fn read(r) {
  let bits : Int64 = Binary::read(r)
  let value = bits.reinterpret_as_double()
  guard !value.is_nan() else { fail("invalid binary REAL") }
  value
}

///|
impl Binary for Bool with fn write(value, w) {
  w.uint(if value { 1U } else { 0U })
}

///|
impl Binary for Bool with fn read(r) {
  match r.uint() {
    0U => false
    1U => true
    _ => fail("invalid binary bool")
  }
}

///|
impl Binary for String with fn write(value, w) {
  let id = match w.ids.get(value) {
    Some(id) => id
    None => {
      let id = w.strings.length().reinterpret_as_uint()
      w.ids[value] = id
      w.strings.push(value)
      id
    }
  }
  w.uint(id)
}

///|
impl Binary for String with fn read(r) {
  let n = r.uint()
  guard n < r.strings.length().reinterpret_as_uint() else {
    fail("invalid binary string reference")
  }
  r.strings[n.reinterpret_as_int()]
}

///|
impl Binary for Bytes with fn write(value, w) {
  w.uint(value.length().reinterpret_as_uint())
  w.out.write_bytes(value[:])
}

///|
impl Binary for Bytes with fn read(r) {
  r.blob()
}

///|
impl[A : Binary] Binary for Array[A] with fn write(values, w) {
  guard values.length() <= 100000 else { fail("binary array resource limit") }
  w.uint(values.length().reinterpret_as_uint())
  for value in values {
    Binary::write(value, w)
  }
}

///|
impl[A : Binary] Binary for Array[A] with fn read(r) {
  r.enter()
  defer r.leave()
  let n = r.length()
  guard n <= 100000 else { fail("binary array resource limit") }
  let values = []
  for _ in 0.. w.uint(0U)
    Some(value) => {
      w.uint(1U)
      Binary::write(value, w)
    }
  }
}

///|
impl[A : Binary] Binary for A? with fn read(r) {
  match r.uint() {
    0U => None
    1U => Some(Binary::read(r))
    _ => fail("invalid binary option")
  }
}

///|
impl[A : Binary, B : Binary] Binary for (A, B) with fn write(value, w) {
  Binary::write(value.0, w)
  Binary::write(value.1, w)
}

///|
impl[A : Binary, B : Binary] Binary for (A, B) with fn read(r) {
  (Binary::read(r), Binary::read(r))
}

///|
impl Binary for Value with fn write(value, w) {
  match value {
    Null => w.uint(0U)
    Integer(v) => {
      w.uint(1U)
      Binary::write(v, w)
    }
    Real(v) => {
      w.uint(2U)
      Binary::write(v, w)
    }
    Text(v) => {
      w.uint(3U)
      Binary::write(v, w)
    }
    Blob(v) => {
      w.uint(4U)
      Binary::write(v, w)
    }
  }
}

///|
impl Binary for Value with fn read(r) {
  match r.uint() {
    0U => Null
    1U => Integer(Binary::read(r))
    2U => Real(Binary::read(r))
    3U => Text(Binary::read(r))
    4U => Blob(Binary::read(r))
    _ => fail("unknown binary value tag")
  }
}