//! `wai.tensor.weft` (SPEC §5, *WFT1 tensor frames*): the corpus regenerates and every vector
//! gets its outcome; the writers reproduce the format's own frames byte for byte; SPEC lists
//! exactly the decoder's error classes and admitted modes; and a frame rides a `WAI1`
//! envelope, is dispatched under its capability and decodes to its plaintext.
#![cfg(feature = "weft")]

use std::path::{Path, PathBuf};
use wai::codecs::weft::{self, corpus, ErrorClass};
use wai::container::{Conditioning, Manifest, ModelRequirement, Wai};

fn corpus_dir() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../tensor-conformance")
}

#[test]
fn the_corpus_regenerates_and_every_vector_gets_its_outcome() {
    let fails = corpus::verify(&corpus_dir());
    assert!(fails.is_empty(), "{}", fails.join("\n"));
    // Every class is reached by some vector, and so is every admitted mode's decode.
    let doc: serde_json::Value = serde_json::from_slice(&std::fs::read(corpus_dir().join("vectors.json")).unwrap()).unwrap();
    for c in ErrorClass::all() {
        assert!(doc["vectors"].as_array().unwrap().iter().any(|v| v["expect"]["refuse"] == c.label()), "no vector is refused as {}", c.label());
    }
    for mode in weft::WEFT_ADMITTED_MODES {
        let n = doc["vectors"].as_array().unwrap().iter()
            .filter(|v| v["expect"].get("decode").is_some())
            .filter(|v| std::fs::read(corpus_dir().join(v["file"].as_str().unwrap())).unwrap()[7] == mode)
            .count();
        assert!(n >= 3, "mode {mode}: {n} vectors decode");
    }
}

/// The format's encoders write RAW, TENSOR and FLOAT_TENSOR deterministically: the writers
/// here give the format's own valid frames, byte for byte, from their plaintexts.
#[test]
fn the_writers_reproduce_the_formats_frames() {
    let mut n = 0;
    for u in corpus::UPSTREAM.iter().filter(|u| u.expect == "decode") {
        let frame = std::fs::read(corpus_dir().join(format!("vectors/{}/frame.wft", u.name))).unwrap();
        let d = weft::decode(&frame).unwrap();
        let again = match (d.mode, &d.tensor) {
            (weft::WEFT_MODE_RAW, _) => {
                let chunks = u32::from_le_bytes(frame[32..36].try_into().unwrap());
                let size = if chunks > 0 { Some(u32::from_le_bytes(frame[96 + 8..96 + 12].try_into().unwrap()) as usize) } else { None };
                weft::write_raw(&d.plaintext, size)
            }
            (weft::WEFT_MODE_TENSOR, Some(t)) => weft::write_tensor(&t.dtype, &t.shape, &d.plaintext).unwrap(),
            (weft::WEFT_MODE_FLOAT_TENSOR, Some(t)) => weft::write_float_tensor(&t.dtype, &t.shape, &d.plaintext).unwrap(),
            other => panic!("{}: {other:?}", u.name),
        };
        assert!(again == frame, "{}: the writer's frame differs from the format's", u.name);
        n += 1;
    }
    assert!(n >= 9, "{n} frames rewritten");
}

/// SPEC §5's paragraph (one paragraph, to its blank line) lists the format's error classes and the admitted modes this decoder has.
#[test]
fn spec_states_the_classes_and_modes() {
    let spec = std::fs::read_to_string(Path::new(env!("CARGO_MANIFEST_DIR")).join("../SPEC.md")).unwrap();
    let at = spec.find("**WFT1 tensor frames.**").expect("the SPEC §5 paragraph");
    let para = &spec[at..];
    let para = &para[..para.find("\n\n").unwrap_or(para.len())];
    for c in ErrorClass::all() {
        assert!(para.contains(&format!("`{}`", c.label())), "SPEC names no `{}`", c.label());
    }
    for name in ["`RAW` (0)", "`TENSOR` (6)", "`FLOAT_TENSOR` (9)"] {
        assert!(para.contains(name), "SPEC admits no {name}");
    }
}

/// A frame rides a WAI1 envelope: dispatched under its capability when the sink advertises it,
/// it decodes to its plaintext; the envelope's bytes round-trip.
#[test]
fn a_frame_in_an_envelope_dispatches_and_decodes() {
    let elements: Vec<u8> = (0..32u16).flat_map(|i| (0x3F80u16 ^ (i << 3)).to_le_bytes()).collect();
    let frame = weft::write_float_tensor("bf16", &[4, 8], &elements).unwrap();
    let env = Wai::new(
        Manifest::new("binary", "replicate", ModelRequirement::new("wai.tensor.weft"), Conditioning::new("wft1")),
        frame,
    );
    let back = Wai::from_bytes(&env.to_bytes().unwrap()).unwrap();
    assert!(back.check_candidates().is_ok());
    let d = back.dispatch_verified(|c| c == "wai.tensor.weft", wai::container::no_parameter_sets()).unwrap();
    assert_eq!(d.capability, "wai.tensor.weft");
    let decoded = weft::decode(&back.payload).unwrap();
    assert_eq!(decoded.plaintext, elements);
    assert_eq!(decoded.tensor.unwrap().shape, vec![4, 8]);
    // The registry's classes for it.
    assert_eq!(wai::codecs::capability_replicate_class("wai.tensor.weft"), Some(wai::codecs::ReplicateClass::StandardDefined));
    assert!(wai::codecs::is_royalty_free("wai.tensor.weft"));
    assert!(!wai::codecs::is_candidate("wai.tensor.weft") && wai::codecs::is_dispatchable("wai.tensor.weft"));
}