fn main() {
    let from_hcie = std::fs::read("_images/_psd_stil_test/inner_shadow/black_triangle_green_inner_shadow_normal_blend_from_hcie.psd").unwrap();
    let orig = std::fs::read("_images/_psd_stil_test/inner_shadow/black_triangle_green_inner_shadow_normal_blend.psd").unwrap();

    // Extract merged image pixels from both
    let orig_psd = hcie_psd::Psd::from_bytes(&orig).unwrap();
    let from_psd = hcie_psd::Psd::from_bytes(&from_hcie).unwrap();

    let orig_rgba = orig_psd.rgba();
    let from_rgba = from_psd.rgba();

    println!("ORIG merged RGBA: {} bytes, non-zero={}", orig_rgba.len(), orig_rgba.iter().filter(|&&b| b > 0).count());
    println!("FROM merged RGBA: {} bytes, non-zero={}", from_rgba.len(), from_rgba.iter().filter(|&&b| b > 0).count());

    // Compare merged pixels
    let mut diff_pixels = 0;
    let mut max_diff: u8 = 0;
    for i in 0..orig_rgba.len().min(from_rgba.len()) {
        let d = (orig_rgba[i] as i16 - from_rgba[i] as i16).unsigned_abs() as u8;
        if d > 0 {
            diff_pixels += 1;
            max_diff = max_diff.max(d);
        }
    }
    println!("Merged pixel diff: {} bytes, max={}", diff_pixels, max_diff);

    // Now check individual layer pixels
    println!("\n=== Layer pixel analysis ===");
    let orig_layers = hcie_psd::import_psd(std::path::Path::new("_images/_psd_stil_test/inner_shadow/black_triangle_green_inner_shadow_normal_blend.psd")).unwrap();
    let from_layers = hcie_psd::import_psd(std::path::Path::new("_images/_psd_stil_test/inner_shadow/black_triangle_green_inner_shadow_normal_blend_from_hcie.psd")).unwrap();

    for (i, (ol, fl)) in orig_layers.iter().zip(from_layers.iter()).enumerate() {
        println!("Layer {}: '{}' ORIG={}x{} FROM={}x{}", i, ol.name, ol.width, ol.height, fl.width, fl.height);
        // Count non-zero pixels per channel
        let mut orig_ch = [0u32; 4]; // R, G, B, A non-zero counts
        let mut from_ch = [0u32; 4];
        for chunk in ol.pixels.chunks_exact(4) {
            for c in 0..4 { if chunk[c] > 0 { orig_ch[c] += 1; } }
        }
        for chunk in fl.pixels.chunks_exact(4) {
            for c in 0..4 { if chunk[c] > 0 { from_ch[c] += 1; } }
        }
        println!("  ORIG  non-zero: R={} G={} B={} A={}", orig_ch[0], orig_ch[1], orig_ch[2], orig_ch[3]);
        println!("  FROM  non-zero: R={} G={} B={} A={}", from_ch[0], from_ch[1], from_ch[2], from_ch[3]);

        // Show unique (R,G,B,A) tuples for first 20 different pixels
        let mut diff_count = 0;
        for (j, (op, fp)) in ol.pixels.chunks_exact(4).zip(fl.pixels.chunks_exact(4)).enumerate() {
            if op != fp {
                if diff_count < 5 {
                    let x = j % ol.width as usize;
                    let y = j / ol.width as usize;
                    println!("  pixel[{},{}]: ORIG=({},{},{},{}) FROM=({},{},{},{})",
                        x, y, op[0], op[1], op[2], op[3], fp[0], fp[1], fp[2], fp[3]);
                }
                diff_count += 1;
            }
        }
        println!("  Total different pixels: {} / {}", diff_count, ol.pixels.len() / 4);
    }
}