//! `wai wrap` writes an envelope that pins no prior, so SPEC §7 limits the intent
//! it may claim: `replicate` only over the standard classes, where a sink accepts
//! it unpinned. It used to write `intent = replicate` over every capability,
//! `wai.image.jpegai` included. These tests run the binary itself; the rule it
//! applies is `codecs::unpinned_envelope_intent`, which the library tests check
//! for every registered capability.
//!
//! `wrap` needs no codec feature, so these run in the no-system-dependency CI
//! matrix (`--test cli_wrap_intent`).

use std::path::{Path, PathBuf};
use std::process::{Command, Output};

use wai::container::{Wai, WaiMulti};

/// The committed JPEG AI reference codestream; `wrap` treats any payload as opaque.
fn payload() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/vectors/jpegai/test256.bin")
}

fn scratch(name: &str) -> PathBuf {
    let dir = Path::new(env!("CARGO_TARGET_TMPDIR")).join("cli_wrap_intent");
    std::fs::create_dir_all(&dir).unwrap();
    let p = dir.join(name);
    let _ = std::fs::remove_file(&p);
    p
}

fn wrap(cap: &str, out: &Path, extra: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_wai"))
        .arg("wrap").arg(cap).arg(payload()).arg("-o").arg(out).args(extra)
        .output()
        .expect("run wai")
}

#[test]
fn wrap_refuses_replicate_over_jpegai_and_writes_nothing() {
    for extra in [&[][..], &["--intent", "replicate"][..]] {
        let out = scratch("jpegai.wai");
        let run = wrap("wai.image.jpegai", &out, extra);
        let stderr = String::from_utf8_lossy(&run.stderr);
        assert!(!run.status.success(), "{extra:?}: wrap must refuse; stderr: {stderr}");
        assert!(stderr.contains("not writing intent=replicate over wai.image.jpegai"), "{stderr}");
        assert!(stderr.contains("entropy-consistency"), "the refusal names the tier: {stderr}");
        assert!(stderr.contains("--intent"), "the refusal says how to proceed: {stderr}");
        assert!(!out.exists(), "{extra:?}: a refused wrap must not write an envelope");
    }
}

#[test]
fn wrap_writes_another_intent_over_jpegai_when_asked() {
    let out = scratch("jpegai-improve.wai");
    let run = wrap("wai.image.jpegai", &out, &["--intent", "improve"]);
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = Wai::read(&out).unwrap();
    assert_eq!(env.intent(), "improve");
    assert_eq!(env.replicate_refusal(), None);
    assert_eq!(env.payload, std::fs::read(payload()).unwrap(), "the payload is carried byte-identically");
}

#[test]
fn wrap_refuses_replicate_when_the_fallback_is_jpegai() {
    // The primary backs an unpinned replicate, but a sink without it decodes
    // through the fallback (SPEC §4 step 5), where replicate is refused.
    for extra in [&["--fallback", "wai.image.jpegai"][..],
                  &["--fallback", "wai.image.jpegai", "--intent", "replicate"][..]] {
        let out = scratch("jp2-fb-jpegai.wai");
        let run = wrap("wai.image.jp2", &out, extra);
        let stderr = String::from_utf8_lossy(&run.stderr);
        assert!(!run.status.success(), "{extra:?}: wrap must refuse; stderr: {stderr}");
        assert!(stderr.contains("with fallback wai.image.jpegai"), "{stderr}");
        assert!(stderr.contains("entropy-consistency"), "the refusal names the tier: {stderr}");
        assert!(!out.exists(), "{extra:?}: a refused wrap must not write an envelope");
    }
    // Another intent is carried, fallback and all.
    let out = scratch("jp2-fb-jpegai-improve.wai");
    let run = wrap("wai.image.jp2", &out, &["--fallback", "wai.image.jpegai", "--intent", "improve"]);
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = Wai::read(&out).unwrap();
    assert_eq!(env.intent(), "improve");
    assert_eq!(env.fallback(), Some("wai.image.jpegai"));
}

#[test]
fn wrap_still_writes_replicate_with_a_standard_fallback() {
    let out = scratch("jp2-fb-png.wai");
    let run = wrap("wai.image.jp2", &out, &["--fallback", "wai.image.png"]);
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = Wai::read(&out).unwrap();
    assert_eq!(env.intent(), "replicate");
    assert_eq!(env.fallback(), Some("wai.image.png"));
}

#[test]
fn wrap_refuses_an_unpinned_replicate_over_an_integer_exact_neural_codec() {
    // Integer-exact, but `replicate` over it needs a pinned integer-exact prior,
    // which `wrap` does not write.
    let out = scratch("int_hyper.wai");
    let run = wrap("wai.neural.int_hyper", &out, &[]);
    assert!(!run.status.success());
    assert!(String::from_utf8_lossy(&run.stderr).contains("no pinned prior"));
    assert!(!out.exists());
}

#[test]
fn wrap_still_writes_replicate_over_a_standard_codec() {
    // `wai.image.jp2` is StandardTolerance: replicate is honoured, promising the
    // standard's decoder conformance, and needs no prior.
    let out = scratch("jp2.wai");
    let run = wrap("wai.image.jp2", &out, &[]);
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = Wai::read(&out).unwrap();
    assert_eq!(env.intent(), "replicate");
    assert_eq!(env.replicate_refusal(), None, "a sink accepts what wrap wrote");
    assert_eq!(env.payload, std::fs::read(payload()).unwrap());
}

#[test]
fn wrap_holds_a_companion_envelope_to_the_same_intent_rule() {
    // With `--companion` the output is a WAI2 envelope; its intent is checked over
    // the base payload's capability as the WAI1 form's is (and over each
    // companion's). HDR dynamic metadata may bind to a neural video payload
    // (SPEC §7.1), whose class is NeuralFloat.
    let meta = payload();
    let meta = meta.to_str().unwrap();
    let hdr = ["--companion", "wai.meta.hdr10plus", meta];
    for extra in [hdr.to_vec(), [&["--intent", "replicate"][..], &hdr[..]].concat()] {
        let out = scratch("dcvc-hdr.wai");
        let run = wrap("wai.neural.dcvc_rt", &out, &extra);
        let stderr = String::from_utf8_lossy(&run.stderr);
        assert!(!run.status.success(), "{extra:?}: wrap must refuse; stderr: {stderr}");
        assert!(stderr.contains("not writing intent=replicate over wai.neural.dcvc_rt"), "{stderr}");
        assert!(!out.exists(), "{extra:?}: a refused wrap must not write an envelope");
    }
    // Another intent is carried, companion and all.
    let out = scratch("dcvc-hdr-improve.wai");
    let run = wrap("wai.neural.dcvc_rt", &out, &[&["--intent", "improve"][..], &hdr[..]].concat());
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = WaiMulti::read(&out).unwrap();
    assert_eq!(env.intent(), "improve");
    assert_eq!(env.check_component_roles(), Ok(()));
    // A standard base still gets `replicate`.
    let out = scratch("hevc-hdr.wai");
    let run = wrap("wai.video.hevc", &out, &hdr);
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = WaiMulti::read(&out).unwrap();
    assert_eq!(env.intent(), "replicate");
    assert_eq!(env.check_component_roles(), Ok(()));
    // The WAI2 form takes no fallback; that is the refusal, whatever the
    // fallback's class, rather than the WAI1 fallback-intent check.
    let out = scratch("hevc-hdr-fb.wai");
    let run = wrap("wai.video.hevc", &out,
                   &[&["--fallback", "wai.image.jpegai"][..], &hdr[..]].concat());
    let stderr = String::from_utf8_lossy(&run.stderr);
    assert!(!run.status.success(), "wrap must refuse; stderr: {stderr}");
    assert!(stderr.contains("--fallback names a WAI1 alternative"), "{stderr}");
    assert!(!out.exists(), "a refused wrap must not write an envelope");
}

/// SPEC §5 pins the payload of each WAI-native integer codec to a binary format
/// (`extensions/integer-payloads.md`). `wai wrap` parses the payload as a sink does
/// and writes nothing when it is not its capability's format: a tool's JSON output
/// (`bad_magic`, converted first, never wrapped), another format, a `WIV1` cut inside
/// its header (`stream_length`), and a keyframe-0 `WIV1` under `wai.video.int_hyper`
/// (`keyframe_capability_mismatch`), whose magic and version are right. The binary
/// payloads wrap; `wai inspect` reports what a parse finds in an envelope another
/// writer made.
#[test]
fn wrap_refuses_a_payload_that_is_not_the_pinned_integer_format() {
    let v = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/vectors");
    let wrap_file = |cap: &str, input: &Path, out: &Path, extra: &[&str]| -> Output {
        Command::new(env!("CARGO_BIN_EXE_wai"))
            .arg("wrap").arg(cap).arg(input).arg("-o").arg(out).args(extra)
            .output()
            .expect("run wai")
    };
    for (cap, json, bin, code) in [
        ("wai.video.int_motion", "int_video/int_video_bitstream.json", "int_video/int_video_bitstream.wiv1", "bad_magic"),
        ("wai.neural.int_hyper", "int_hyper/tiny_bitstream.json", "int_hyper/tiny_bitstream.wih1", "bad_magic"),
        ("wai.audio.int_codec", "int_video/video_nk_bitstream.wiv1", "int_audio/audio_bitstream.wia1", "format_capability_mismatch"),
        ("wai.splat.int_codec", "int_splat/splat.json", "int_splat/splat.wis1", "bad_magic"),
        ("wai.video.int_hyper", "int_video/int_video_bitstream.wiv1", "int_video/video_nk_bitstream.wiv1", "keyframe_capability_mismatch"),
    ] {
        let out = scratch("int-payload.wai");
        let run = wrap_file(cap, &v.join(json), &out, &["--intent", "improve"]);
        let stderr = String::from_utf8_lossy(&run.stderr);
        assert!(!run.status.success(), "{cap} {json}: wrap must refuse; stderr: {stderr}");
        assert!(stderr.contains(code) && stderr.contains("integer-payloads"), "{cap}: {stderr}");
        assert!(!out.exists(), "{cap}: a refused wrap must not write an envelope");
        let run = wrap_file(cap, &v.join(bin), &out, &["--intent", "improve"]);
        assert!(run.status.success(), "{cap} {bin}: {}", String::from_utf8_lossy(&run.stderr));
        assert_eq!(Wai::read(&out).unwrap().payload, std::fs::read(v.join(bin)).unwrap());
    }
    // A WIV1 cut inside its fixed header.
    let cut = scratch("int-payload-cut.wiv1");
    std::fs::write(&cut, &std::fs::read(v.join("int_video/int_video_bitstream.wiv1")).unwrap()[..30]).unwrap();
    let out = scratch("int-payload-cut.wai");
    let run = wrap_file("wai.video.int_motion", &cut, &out, &["--intent", "improve"]);
    assert!(!run.status.success() && String::from_utf8_lossy(&run.stderr).contains("stream_length"), "{}", String::from_utf8_lossy(&run.stderr));
    assert!(!out.exists());
    // The same rule for a WAI2 base.
    let out = scratch("int-payload-hdr.wai");
    let run = wrap_file("wai.video.int_motion", &v.join("int_video/int_video_bitstream.json"), &out,
                        &["--companion", "wai.meta.hdr10plus", payload().to_str().unwrap()]);
    assert!(!run.status.success() && String::from_utf8_lossy(&run.stderr).contains("bad_magic"));
    assert!(!out.exists());
    // inspect reports an envelope that carries the JSON form.
    let out = scratch("int-payload-json.wai");
    wai::container::Wai::new(
        wai::container::Manifest::new("video", "improve", wai::container::ModelRequirement::new("wai.video.int_motion"),
                                      wai::container::Conditioning::new("bytes")),
        std::fs::read(v.join("int_video/int_video_bitstream.json")).unwrap(),
    ).write(&out).unwrap();
    let run = Command::new(env!("CARGO_BIN_EXE_wai")).arg("inspect").arg(&out).output().expect("run wai");
    let stdout = String::from_utf8_lossy(&run.stdout);
    assert!(stdout.contains("integer payload:") && stdout.contains("bad_magic"), "{stdout}");
    // ...and one whose keyframe-0 WIV1 sits under wai.video.int_hyper.
    let out = scratch("int-payload-k0.wai");
    wai::container::Wai::new(
        wai::container::Manifest::new("video", "improve", wai::container::ModelRequirement::new("wai.video.int_hyper"),
                                      wai::container::Conditioning::new("bytes")),
        std::fs::read(v.join("int_video/int_video_bitstream.wiv1")).unwrap(),
    ).write(&out).unwrap();
    let run = Command::new(env!("CARGO_BIN_EXE_wai")).arg("inspect").arg(&out).output().expect("run wai");
    let stdout = String::from_utf8_lossy(&run.stdout);
    assert!(stdout.contains("integer payload:") && stdout.contains("keyframe_capability_mismatch"), "{stdout}");
    // ...and an encrypted one, whose ciphertext is checked only after decryption.
    let out = scratch("int-payload-encrypted.wai");
    let mut m = wai::container::Manifest::new("video", "improve", wai::container::ModelRequirement::new("wai.video.int_motion"),
                                              wai::container::Conditioning::new("bytes"));
    m.security = Some(wai::container::Security::new("aes-256-gcm", 7));
    wai::container::Wai::new(m, vec![0x5a; 64]).write(&out).unwrap();
    let run = Command::new(env!("CARGO_BIN_EXE_wai")).arg("inspect").arg(&out).output().expect("run wai");
    let stdout = String::from_utf8_lossy(&run.stdout);
    assert!(stdout.contains("integer payload:   encrypted"), "{stdout}");
}

/// SPEC §5, *Payload of `wai.generate.spectral`*: `wrap` reads the instruction object of
/// form v0 in every build, the generator's own feature or not. It carries the committed
/// object under intent `create`, refuses `replicate` over the generator (a generator
/// has no source to replicate), and refuses the same object in another spacing — as
/// capability or as fallback — writing nothing.
#[test]
fn wrap_carries_only_an_instruction_object_under_the_generator() {
    let v: serde_json::Value = serde_json::from_slice(&std::fs::read(
        Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/vectors/generate/instr-v0.json")).unwrap()).unwrap();
    let object = v["object"].as_str().unwrap();
    let good = scratch("instr-v0.payload");
    std::fs::write(&good, object).unwrap();
    let wrap_file = |cap: &str, payload: &Path, out: &Path, extra: &[&str]| {
        Command::new(env!("CARGO_BIN_EXE_wai")).arg("wrap").arg(cap).arg(payload).arg("-o").arg(out).args(extra)
            .output().expect("run wai")
    };
    let out = scratch("generate-create.wai");
    let run = wrap_file("wai.generate.spectral", &good, &out, &["--intent", "create"]);
    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
    let env = Wai::read(&out).unwrap();
    assert_eq!((env.capability(), env.intent()), ("wai.generate.spectral", "create"));
    assert_eq!(env.payload, object.as_bytes(), "the object is carried byte for byte");

    let out = scratch("generate-replicate.wai");
    let run = wrap_file("wai.generate.spectral", &good, &out, &["--intent", "replicate"]);
    assert!(!run.status.success() && !out.exists());
    assert!(String::from_utf8_lossy(&run.stderr).contains("GenerativeDeterministic"));

    let spaced = scratch("instr-v0-spaced.payload");
    std::fs::write(&spaced, object.replace("\"seed\":7", "\"seed\": 7")).unwrap();
    for (cap, extra) in [("wai.generate.spectral", &["--intent", "create"][..]),
                         ("wai.image.png", &["--fallback", "wai.generate.spectral", "--intent", "create"][..])] {
        let out = scratch("generate-spaced.wai");
        let run = wrap_file(cap, &spaced, &out, extra);
        let stderr = String::from_utf8_lossy(&run.stderr);
        assert!(!run.status.success(), "{cap} {extra:?}: wrap must refuse");
        assert!(stderr.contains("instruction object of form v0") && stderr.contains("canonical"), "{cap} {extra:?}: {stderr}");
        assert!(!out.exists(), "{cap} {extra:?}: a refused wrap must not write an envelope");
    }
}