///|
struct BinaryCatalog {
  schema : Bytes
  statements : Bytes
  storage : Bytes
  error : String
}

///|
struct BinaryResult {
  data : Bytes
  error : String
  full : Bool
  serial : Int32
}

///|
struct DefinedDatabase {
  core : AotDatabase
  schema_id : String
}

///|
// Build-only bridge. New runtime entry points never reference this JSON reader.
pub fn pack_program_binary(artifact : String) -> BinaryCatalog {
  try {
    guard artifact.length() <= 1048576 else {
      fail("compiled program resource limit")
    }
    let compiled : CompiledProgram = @json.from_json(@json.parse(artifact))
    ignore(prepare_compiled_program(compiled, ""))
    // The legacy compiler omits declaration spelling when no metadata query
    // needs it. Recover it at build time so schema identity depends on DDL,
    // independently of which prepared statements the application includes.
    for table in compiled.schema.tables {
      guard parse_statement(lex(table.sql)) is CreateTable(definition, _) &&
        definition.columns.length() == table.columns.length() else {
        fail("binary schema declaration mismatch")
      }
      for i, column in table.columns {
        guard column.name == definition.columns[i].name else {
          fail("binary schema column mismatch")
        }
        column.default_source = definition.columns[i].default_source
      }
    }
    let schema_writer = binary_writer()
    Binary::write(compiled.schema, schema_writer)
    let schema = binary_finish(schema_writer, 1)
    let schema_id = binary_id(schema)
    let query_writer = binary_writer()
    Binary::write(schema_id, query_writer)
    Binary::write(compiled.queries, query_writer)
    let statements = binary_finish(query_writer, 2)
    let storage = match compiled.storage {
      None => b""
      Some(plan) => {
        let w = binary_writer()
        Binary::write(schema_id, w)
        Binary::write(plan.format, w)
        Binary::write(plan.page_size, w)
        Binary::write(@base64.decode(plan.image), w)
        Binary::write(plan.trees, w)
        binary_finish(w, 3)
      }
    }
    { schema, statements, storage, error: "", }
  } catch {
    e => { schema: b"", statements: b"", storage: b"", error: public_error(e), }
  }
}

///|
pub fn binary_catalog_schema(catalog : BinaryCatalog) -> Bytes {
  catalog.schema
}

///|
pub fn binary_catalog_statements(catalog : BinaryCatalog) -> Bytes {
  catalog.statements
}

///|
pub fn binary_catalog_storage(catalog : BinaryCatalog) -> Bytes {
  catalog.storage
}

///|
pub fn binary_catalog_info(catalog : BinaryCatalog) -> String {
  if catalog.error != "" {
    return ({ "error": catalog.error } : Json).stringify()
  }
  (
    {
      "format": "sqlike-defined@1",
      "schemaId": binary_id(catalog.schema),
      "programId": binary_id(catalog.statements),
    } : Json).stringify()
}

///|
fn binary_program(
  schema : Bytes,
  statements : Bytes,
) -> (Program, String) raise SqlError {
  let schema_reader = binary_reader(schema, 1, 1048576)
  let store : Store = Binary::read(schema_reader)
  schema_reader.finish()
  let schema_id = binary_id(schema)
  let query_reader = binary_reader(statements, 2, 1048576)
  let required_schema : String = Binary::read(query_reader)
  guard required_schema == schema_id else {
    fail("prepared statement schema mismatch")
  }
  let queries : Array[CompiledQuery] = Binary::read(query_reader)
  query_reader.finish()
  for table in store.tables {
    let ctx = evaluation(
      store,
      [],
      row_environment(
        table,
        { id: 0L, values: Array::make(table.columns.length(), Null), },
        table.name,
      ),
    )
    for column in table.columns {
      prepare_expression(
        column.default_value,
        evaluation(store, [], []),
        false,
        false,
      )
    }
    for check in table.checks {
      prepare_expression(check, ctx, false, false)
    }
    prepare_foreign_table(store, table)
  }
  for object in store.objects {
    if object.kind == "trigger" {
      prepare_trigger(store, get_table(store, object.table), object)
    }
  }
  let program = prepare_compiled_program(
    { format: "moon-aot@1", schema: store, queries, storage: None, },
    binary_id(statements),
  )
  (program, schema_id)
}

///|
/// Load fixed schema and named prepared queries without parsing SQL or JSON.
pub fn Program::load_binary(
  schema : Bytes,
  statements : Bytes,
) -> Program raise SqliteError {
  binary_program(schema, statements).0 catch {
    error => raise interface_error(public_error(error))
  }
}

///|
pub fn defined_open(
  schema : Bytes,
  statements : Bytes,
  image : Bytes,
) -> DefinedDatabase {
  try {
    let (program, schema_id) = binary_program(schema, statements)
    let core : AotDatabase = {
      connection: Some(Connection::from_program(program)),
      program: Some(program),
      error: None,
    }
    let db = { core, schema_id, }
    if !image.is_empty() {
      defined_restore_checked(db, image)
    }
    db
  } catch {
    e =>
      {
        core: { connection: None, program: None, error: Some(public_error(e)), },
        schema_id: "",
      }
  }
}

///|
pub fn defined_info(db : DefinedDatabase) -> String {
  try {
    let (connection, program) = db.core.ready()
    (
      {
        "schemaId": db.schema_id,
        "programId": program.id,
        "serial": connection.database.serial,
        "schemaVersion": connection.database.store.cookie,
        "queryCount": program.queries.length(),
        "autocommit": database_autocommit(connection.database),
      } : Json).stringify()
  } catch {
    e => ({ "error": public_error(e) } : Json).stringify()
  }
}

///|
pub fn defined_execute(
  db : DefinedDatabase,
  name : String,
  bindings : String,
) -> String {
  aot_execute(db.core, name, bindings)
}

///|
pub fn defined_query_info(db : DefinedDatabase, name : String) -> String {
  aot_query_info(db.core, name)
}

///|
pub fn defined_set_clock(db : DefinedDatabase, millis : String) -> String {
  aot_set_clock(db.core, millis)
}

///|
pub fn defined_clone(db : DefinedDatabase) -> DefinedDatabase {
  { core: aot_clone(db.core), schema_id: db.schema_id, }
}

///|
pub fn defined_copy_connection_state(
  target : DefinedDatabase,
  source : DefinedDatabase,
) -> String {
  aot_copy_connection_state(target.core, source.core)
}

///|
pub fn defined_ack_delta(db : DefinedDatabase, serial : Int32) -> String {
  aot_ack_delta(db.core, serial)
}

///|
pub fn binary_data(result : BinaryResult) -> Bytes {
  result.data
}

///|
pub fn binary_info(result : BinaryResult) -> String {
  if result.error != "" {
    ({ "error": result.error } : Json).stringify()
  } else {
    (
      {
        "full": result.full,
        "serial": result.serial,
        "bytes": result.data.length(),
      } : Json).stringify()
  }
}