///|
#derive(ToJson, FromJson)
priv struct LtxBinaryPageState {
  format : String
  pageSize : Int32
  pageCount : Int32
  txid : String
  checksum : String
  seal : String
}

///|
/// Header seal detects accidental cursor corruption without scanning the catalog.
fn ltx_binary_seal(
  size : Int32,
  count : Int32,
  txid : UInt64,
  checksum : UInt64,
) -> String {
  let bytes = @buffer.Buffer()
  bytes.write_bytes(b"LTXCRC2\x00")
  ltx_be(bytes, size.to_uint64(), 4)
  ltx_be(bytes, count.to_uint64(), 4)
  ltx_be(bytes, txid, 8)
  ltx_be(bytes, checksum, 8)
  let crc = Crc64::{ value: 0xffffffffffffffffUL, }
  crc.write(bytes.to_bytes())
  crc.sum().to_string()
}

///|
fn ltx_binary_result(
  result : LtxResult,
  size : Int32,
  count : Int32,
  txid : String,
  checksum : UInt64,
  crcs : Bytes,
) -> LtxResult raise {
  let state : LtxBinaryPageState = {
    format: "ltx-page-state@2",
    pageSize: size,
    pageCount: count,
    txid,
    checksum: checksum.to_string(),
    seal: ltx_binary_seal(size, count, parse_txid(txid), checksum),
  }
  let info = @json.parse(result.metadata)
  guard info is Object(fields) else { raise Invalid("invalid LTX result") }
  fields["pageState"] = @json.to_json(state)
  fields["pageChecksums"] = @json.to_json(@base64.encode(crcs))
  ltx_result(result.data, info.stringify())
}

///|
/// previous contains BE64 CRCs for existing input pages, then truncated pages.
/// Snapshot frames recompute the whole post checksum and need no old entries.
fn encode_ltx_pages_binary_checked(
  state : String,
  metadata : String,
  data : Bytes,
  previous : Bytes,
) -> LtxResult raise {
  guard state.length() <= 8388608 &&
    metadata.length() <= 2097152 &&
    data.length() <= MaxImage &&
    previous.length() <= 1048576 else {
    raise Invalid("LTX binary page input limit")
  }
  let json = @json.parse(metadata)
  guard json
    is { "pageSize": size, "pageCount": count, "pages": Array(raw), .. } else {
    raise Invalid("invalid LTX page metadata")
  }
  let size = ltx_json_int(size)
  let count = ltx_json_int(count)
  guard size >= 512 &&
    size <= 65536 &&
    (size & (size - 1)) == 0 &&
    count <= MaxImage / size &&
    raw.length() <= count else {
    raise Invalid("invalid LTX page size/count")
  }
  for page in raw {
    ignore(ltx_json_int(page))
  }
  let input : LtxPageInput = @json.from_json(json)
  guard data.length() == input.pages.length() * size else {
    raise Invalid("LTX page payload size mismatch")
  }
  let min = parse_txid(input.min)
  let max = parse_txid(input.max)
  let time = @string.parse_int64(input.timestamp)
  guard min > 0UL && min <= max && time >= 0L else {
    raise Invalid("invalid LTX page transaction/time")
  }
  let old = @json.parse(if state == "" { "{}" } else { state })
  // The old full catalog is validated once during migration by the legacy codec.
  if old is { "format": "ltx-page-state@1", .. } {
    guard previous.is_empty() else {
      raise Invalid("unexpected legacy CRC payload")
    }
    let result = encode_ltx_pages_checked(state, metadata, data)
    let info = @json.parse(result.metadata)
    guard info is { "pageState": next, .. } else {
      raise Invalid("missing legacy LTX state")
    }
    let next : LtxPageState = @json.from_json(next)
    let crcs = @buffer.Buffer()
    for page in input.pages {
      ltx_be(crcs, @string.parse_uint64(next.pages[page - 1].1, radix=10), 8)
    }
    return ltx_binary_result(
      result,
      size,
      count,
      input.max,
      @string.parse_uint64(next.checksum, radix=10),
      crcs.to_bytes(),
    )
  }
  let mut before_count = 0
  let mut pre = 0UL
  if state != "" {
    guard state.length() <= 1024 &&
      old is { "pageSize": old_size, "pageCount": old_count, .. } else {
      raise Invalid("invalid binary LTX page state")
    }
    ignore(ltx_json_int(old_size))
    before_count = ltx_json_int(old_count)
    let old : LtxBinaryPageState = @json.from_json(old)
    let txid = parse_txid(old.txid)
    pre = @string.parse_uint64(old.checksum, radix=10)
    guard old.format == "ltx-page-state@2" &&
      old.pageSize == size &&
      before_count <= MaxImage / size &&
      txid > 0UL &&
      txid < 0xffffffffffffffffUL &&
      min == txid + 1UL &&
      (pre & ChecksumFlag) != 0UL &&
      old.seal == ltx_binary_seal(size, before_count, txid, pre) else {
      raise Invalid("binary LTX page state/transaction/seal mismatch")
    }
  } else {
    guard min == 1UL && input.snapshot else {
      raise Invalid("initial LTX pages require snapshot")
    }
  }
  let reader = LtxReader::{ data: previous, pos: 0, }
  let crcs = @buffer.Buffer()
  let mut post = if input.snapshot { ChecksumFlag } else { pre }
  let mut last = 0
  let mut grown = 0
  for i, page in input.pages {
    guard page > last && page <= count else {
      raise Invalid("invalid LTX page order/range")
    }
    last = page
    let bytes = data[i * size:(i + 1) * size]
    if page == 1 {
      guard bytes[0:16] == b"SQLite format 3\x00" &&
        (
          (bytes[28].to_int() << 24) |
          (bytes[29].to_int() << 16) |
          (bytes[30].to_int() << 8) |
          bytes[31].to_int()
        ) ==
        count &&
        ((bytes[16].to_int() << 8) | bytes[17].to_int()) ==
        (if size == 65536 { 1 } else { size }) else {
        raise Invalid("LTX page header mismatch")
      }
    }
    let crc = ltx_page_crc(page, bytes)
    let old_crc = if !input.snapshot && page <= before_count {
      reader.be64()
    } else {
      0UL
    }
    if page > before_count {
      grown += 1
    }
    post = ChecksumFlag | (post ^ old_crc ^ crc)
    ltx_be(crcs, crc, 8)
  }
  if input.snapshot {
    guard input.pages.length() == count else {
      raise Invalid("incomplete LTX page snapshot")
    }
  } else {
    guard grown == (if count > before_count { count - before_count } else { 0 }) else {
      raise Invalid("missing grown LTX page")
    }
    for _ in count.. 0 {
    guard input.pages.contains(1) else {
      raise Invalid("missing LTX header page")
    }
  }
  let frames = input.pages
    .mapi((i, page) => (page, data[i * size:(i + 1) * size]))
    .iter()
  let result = ltx_write_pages(
    size,
    count,
    input.min,
    input.max,
    time,
    pre,
    post,
    data.length() / 4,
    frames,
  )
  ltx_binary_result(result, size, count, input.max, post, crcs.to_bytes())
}

///|
pub fn encode_ltx_pages_binary(
  state : String,
  metadata : String,
  data : Bytes,
  previous : Bytes,
) -> LtxResult {
  encode_ltx_pages_binary_checked(state, metadata, data, previous) catch {
    e =>
      ltx_result(
        b"",
        (
          {
            "error": match e {
              Invalid(message) => message
              _ => e.to_string()
            },
          } : Json).stringify(),
      )
  }
}

///|
pub fn encode_ltx_pages_binary_base64(
  state : String,
  metadata : String,
  data : String,
  previous : String,
) -> LtxResult {
  try {
    guard data.length() <= 89478488 && previous.length() <= 1398104 else {
      raise Invalid("LTX binary page input limit")
    }
    encode_ltx_pages_binary(
      state,
      metadata,
      @base64.decode(data),
      @base64.decode(previous),
    )
  } catch {
    e =>
      ltx_result(
        b"",
        (
          {
            "error": match e {
              Invalid(message) => message
              _ => e.to_string()
            },
          } : Json).stringify(),
      )
  }
}