use std::path::Path;

fn main() {
    let path = Path::new("_tmp/roundtrip_output.psd");
    let bytes = std::fs::read(path).expect("read");

    println!("=== Verify roundtrip PSD parseable ===");
    println!("File: {} bytes", bytes.len());

    match hcie_psd::Psd::from_bytes(&bytes) {
        Ok(psd) => {
            println!("Psd::from_bytes OK: {}x{}, {} layers", psd.width(), psd.height(), psd.layers().len());
            for (i, layer) in psd.layers().iter().enumerate() {
                println!("  [{}] '{}' visible={} opacity={}", i, layer.name(), !layer.visible(), layer.opacity());
            }
        }
        Err(e) => println!("Psd::from_bytes FAILED: {:?}", e),
    }

    match hcie_psd::import_psd(path) {
        Ok(layers) => {
            println!("\nimport_psd OK: {} layers", layers.len());
            for (i, layer) in layers.iter().enumerate() {
                println!("  [{}] '{}' effects={} blend={:?}", i, layer.name, layer.effects.len(), layer.blend_mode);
                for (j, fx) in layer.effects.iter().enumerate() {
                    println!("    effect[{}]: {:?}", j, std::mem::discriminant(fx));
                }
            }
        }
        Err(e) => println!("import_psd FAILED: {}", e),
    }

    println!("\n=== Testing composited RGBA ===");
    let psd = hcie_psd::Psd::from_bytes(&bytes).unwrap();
    let rgba = psd.rgba();
    println!("RGBA: {} bytes (expected {})", rgba.len(), psd.width() * psd.height() * 4);
    let non_zero = rgba.iter().filter(|&&b| b > 0).count();
    println!("Non-zero bytes: {} / {}", non_zero, rgba.len());
}