//! How often is a screen's design size READ, and how often is it FABRICATED?
//!
//! `ui_layout.rs` scans the `.rat` records for a `(w,h)` at `+0x18`/`+0x1c` and,
//! finding none, falls back to `(DESIGN_W, DESIGN_H)` = 1280x720. Its own comment
//! says "every screen seen is 1280x720, **which is also the fallback**" -- which
//! is precisely the problem: the fabricated value equals the expected one, so no
//! output of the parser can distinguish a read design size from an invented one.
//! The port sizes its screens off this number.
//!
//! This replicates the scan through the public RATC API and counts.
//!
//!     cargo run -p sylpheed-formats --example design_size_fallback
use std::io::Write;
use std::path::PathBuf;
use sylpheed_formats::{pak::PakArchive, ratc, ui_layout};

fn be32(b: &[u8], o: usize) -> u32 {
    if o + 4 > b.len() {
        return 0;
    }
    u32::from_be_bytes([b[o], b[o + 1], b[o + 2], b[o + 3]])
}

fn main() {
    let root = PathBuf::from(std::env::var("SYLPHEED_DISC").expect("SYLPHEED_DISC"));
    let mut paks: Vec<PathBuf> = std::fs::read_dir(root.join("dat"))
        .expect("dat/")
        .filter_map(|e| e.ok().map(|e| e.path()))
        .filter(|p| p.extension().is_some_and(|x| x == "pak"))
        .collect();
    paks.sort();
    let (mut read, mut fell_back, mut nonstd) = (0usize, 0usize, 0usize);
    for pak in &paks {
        let Ok(ar) = PakArchive::open(pak) else {
            continue;
        };
        let name = pak.file_name().unwrap().to_string_lossy().to_string();
        let (mut r, mut f) = (0usize, 0usize);
        for e in ar.entries() {
            let Ok(by) = ar.read(e) else { continue };
            if !ui_layout::is_build(&by) {
                continue;
            }
            let Some(kids) = ratc::parse(&by) else {
                continue;
            };
            // the same predicate ui_layout uses, over the same records
            // ⚠️ A first version took EVERY RATC child and failed its control:
            // it reported all 965 builds stating a non-1280x720 size, where
            // `screen list` prints 1280x720 for every one. `records` in
            // ui_layout is the `.rat` children only; a T8aD sprite header read
            // at +0x18 is garbage that passes the range test.
            let found = kids
                .iter()
                .filter(|k| k.kind == "RATC" || k.name.ends_with(".rat"))
                .find_map(|k| {
                    let rec = &by[k.offset..(k.offset + k.size).min(by.len())];
                    let (w, h) = (be32(rec, 0x18), be32(rec, 0x1c));
                    (w > 0 && h > 0 && w <= 8192 && h <= 8192).then_some((w, h))
                });
            match found {
                Some((w, h)) => {
                    r += 1;
                    if (w, h) != (1280, 720) {
                        nonstd += 1;
                        println!("  {name} : a build states a NON-standard design size {w}x{h}");
                    }
                }
                None => f += 1,
            }
        }
        if r + f > 0 {
            println!("{name:30} {r:5} read   {f:5} FABRICATED");
            std::io::stdout().flush().ok();
        }
        read += r;
        fell_back += f;
    }
    println!("\n{read} builds state a design size, {fell_back} get the 1280x720 FALLBACK");
    println!("{nonstd} builds state something other than 1280x720");
    println!("--- END ---");
}