//! Does the legacy reader miss a field precisely when its value is shared?
//!
//! The corpus records four "sibling default" rules (`Size_Y` inherits `Size_X`,
//! `FCSRange` inherits `RadarRange`, …) used to recover values for units never
//! visited at runtime. If the rules are really a *deduplication artefact*, then
//! the legacy reader should report the field absent exactly when the two values
//! are equal on disc — and never otherwise.
use sylpheed_formats::{IdxdObject, PakArchive};

fn main() {
    let disc = std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC");
    let arc = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).expect("pak");
    let pairs = [
        ("Size_Y", "Size_X"),
        ("FCSRange", "RadarRange"),
        ("DefencePoint", "AttackVesselPoint"),
    ];
    // legacy-absent x equal-on-disc, as a 2x2 table per pair.
    let mut tally = [[[0usize; 2]; 2]; 3];
    for e in arc.entries() {
        let Ok(bytes) = arc.read(e) else { continue };
        if !IdxdObject::is_idxd(&bytes) {
            continue;
        }
        let Ok(obj) = IdxdObject::parse(&bytes) else { continue };
        let Some(generic) = obj.record("Generic") else { continue };
        if generic.get("Size_X").is_none() {
            continue;
        }
        for (i, (field, sibling)) in pairs.iter().enumerate() {
            let (Some(a), Some(b)) = (generic.get(field), generic.get(sibling)) else {
                continue;
            };
            let legacy_absent = obj.get_f32(field).is_none();
            tally[i][usize::from(legacy_absent)][usize::from(a == b)] += 1;
            // The only cases where the rule PREDICTS WRONG: the reader misses
            // the field and the two values differ, so "inherit the sibling"
            // substitutes a number the disc contradicts.
            if legacy_absent && a != b {
                println!(
                    "  rule-wrong: {:08x} {field} = {a} but {sibling} = {b} (ID {:?})",
                    e.name_hash,
                    obj.get_raw("ID")
                );
            }
        }
    }
    println!("{:<14} {:>10} {:>10} {:>10} {:>10}", "pair", "seen+diff", "seen+eq", "MISS+diff", "MISS+eq");
    for (i, (field, sibling)) in pairs.iter().enumerate() {
        println!(
            "{:<14} {:>10} {:>10} {:>10} {:>10}",
            format!("{field}/{sibling}").chars().take(14).collect::<String>(),
            tally[i][0][0],
            tally[i][0][1],
            tally[i][1][0],
            tally[i][1][1]
        );
    }
    println!("\n'MISS+diff' > 0 refutes 'the reader only misses shared values'.");
    println!("'seen+eq'  > 0 refutes 'a shared value is always invisible'.");
}