// wai-conformance: int-kernels
//! `wai.world.model` integer renderer — a generative INTERACTIVE world whose every
//! frame is byte-exact. The committed transition + synthesis models, an initial
//! latent, and an action walk regenerate a frame sequence whose per-frame and clip
//! hashes reproduce on every machine — replay-equivalence for a *generated* world.
//! Committed tiny vector under `tests/vectors/int_world/`; never skips.
#![cfg(feature = "world_int")]

use std::path::PathBuf;

use wai::int_hyper_synth::IntModel;
use wai::int_world::decode;

fn dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/vectors/int_world")
}

#[test]
fn interactive_world_regenerates_byte_for_byte() {
    let t = IntModel::from_bytes(&std::fs::read(dir().join("world_T.bin")).unwrap()).expect("transition WHM1");
    let gs = IntModel::from_bytes(&std::fs::read(dir().join("world_gs.bin")).unwrap()).expect("synthesis WHM1");
    let j: serde_json::Value =
        serde_json::from_slice(&std::fs::read(dir().join("world.json")).unwrap()).unwrap();

    let c = j["c"].as_u64().unwrap() as usize;
    let lat = j["lat"].as_u64().unwrap() as usize;
    let z0: Vec<i64> = j["z0"].as_array().unwrap().iter().map(|v| v.as_i64().unwrap()).collect();
    let actions: Vec<usize> = j["actions"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap() as usize).collect();

    // From z0 + the action walk, the integer transition + synthesis regenerate the
    // frames in pure i64 — no float, no ML runtime. Each must reproduce its committed
    // hash (a 1-ULP disagreement anywhere in the conv/IGDN/transition would diverge).
    let clip = decode(&t, &gs, &z0, &actions, c, lat).expect("the committed clip renders");
    let want = j["frame_hashes"].as_array().unwrap();
    assert_eq!(clip.frames.len(), want.len(), "frame count = initial + one per action");
    assert_eq!(clip.frames.len(), actions.len() + 1);

    for (i, w) in want.iter().enumerate() {
        let got = format!("{:016x}", clip.frame_hash(i));
        assert_eq!(got, w.as_str().unwrap(), "generated frame {i} must reproduce its committed hash");
    }
    let clip_hash = format!("{:016x}", clip.clip_hash());
    assert_eq!(clip_hash, j["clip_hash"].as_str().unwrap(), "clip hash");
    println!("int_world: {} frames {}px regenerated byte-exact, clip {clip_hash}", clip.frames.len(), clip.frame_px);
}