vyre 0.4.0

use vyre::engine::decode::{decode_regions, DecodeFormat, DecodeRules, DecodedRegion, GpuDecoder};

fn gpu() -> bool {
    match vyre_wgpu::runtime::cached_device() {
        Ok(_) => true,
        Err(error) => {
            panic!("GPU required on this machine (RTX 5090 / 4090 available per project invariant) — do not silently skip: decode engine test: {error}");
            false
        }
    }
}

fn hex_reference(input: &[u8]) -> Vec<DecodedRegion> {
    input
        .windows(2)
        .enumerate()
        .filter_map(|(offset, pair)| {
            let hi = char::from(pair[0]).to_digit(16)?;
            let lo = char::from(pair[1]).to_digit(16)?;
            Some(DecodedRegion::new(offset, 2, vec![((hi << 4) | lo) as u8]))
        })
        .collect()
}

#[test]
fn gpu_decoder_recursive_entry_finds_url_encoded_region() {
    if !gpu() {
        return;
    }

    let decoder = GpuDecoder::new().expect("GPU decoder must initialize");
    let regions = decoder
        .decode_recursive(b"alpha%20beta")
        .expect("recursive decode must run");

    assert!(
        regions
            .iter()
            .any(|region| region == &DecodedRegion::new(5, 3, vec![b' '])),
        "expected URL-decoded space region, got {regions:?}"
    );
}

#[test]
fn decode_regions_matches_hex_reference_for_edges() {
    if !gpu() {
        return;
    }

    assert_eq!(
        decode_regions(b"", DecodeFormat::Hex, &DecodeRules::default()).unwrap(),
        []
    );
    assert_eq!(
        decode_regions(b"4", DecodeFormat::Hex, &DecodeRules::default()).unwrap(),
        []
    );
    assert_eq!(
        decode_regions(b"zzzz", DecodeFormat::Hex, &DecodeRules::default()).unwrap(),
        []
    );

    let all_matches = b"4142";
    assert_eq!(
        decode_regions(all_matches, DecodeFormat::Hex, &DecodeRules::default()).unwrap(),
        hex_reference(all_matches)
    );
}

#[test]
fn decode_rejects_hostile_rules_and_oversized_inputs() {
    let hostile_rules = DecodeRules::with_values(3, 1, 0);
    let rules_error = hostile_rules.validate().unwrap_err();
    assert!(rules_error.to_string().contains("Fix:"));

    let oversized = vec![b'A'; 64 * 1024 * 1024 + 1];
    let oversized_error =
        decode_regions(&oversized, DecodeFormat::Base64, &DecodeRules::default()).unwrap_err();
    assert!(oversized_error.to_string().contains("Fix:"));
}

#[test]
fn decode_repeated_dispatches_do_not_leak_or_return_stale_regions() {
    if !gpu() {
        return;
    }

    for _ in 0..32 {
        let regions = decode_regions(b"%41", DecodeFormat::Url, &DecodeRules::default())
            .expect("repeated URL decode dispatch");
        assert_eq!(regions, vec![DecodedRegion::new(0, 3, vec![b'A'])]);
    }
}