use std::path::Path;

fn main() {
    let orig_path = Path::new("/mnt/extra/00_PROJECTS/hcie-rust-_images/_test_images/example3/Example3-mini.psd");
    let saved_path = Path::new("/mnt/extra/00_PROJECTS/hcie-rust-v4/_tmp/Example3-mini-roundtrip.psd");

    let orig_layers = hcie_psd::import_psd(orig_path).unwrap();
    let saved_layers = hcie_psd::import_psd(saved_path).unwrap();

    let orig_db = orig_layers.iter().find(|l| l.name == "D&B with Retouch4me").unwrap();
    let saved_db = saved_layers.iter().find(|l| l.name == "D&B with Retouch4me").unwrap();

    println!("=== Original D&B layer ===");
    println!("  Width: {}, Height: {}", orig_db.width, orig_db.height);
    println!("  Pixel buffer len: {}", orig_db.pixels.len());
    println!("  Mask bounds: {:?}", orig_db.mask_bounds);
    println!("  Mask default color: {}", orig_db.mask_default_color);
    if let Some(ref mask) = orig_db.mask_pixels {
        println!("  Mask pixels len: {}", mask.len());
        let mut zero_count = 0;
        let mut non_zero_count = 0;
        for &v in mask {
            if v == 0 { zero_count += 1; } else { non_zero_count += 1; }
        }
        println!("  Mask pixels (0 vs non-zero): {} vs {}", zero_count, non_zero_count);
    } else {
        println!("  No mask pixels");
    }
    let mut o_alpha_counts = [0usize; 256];
    for chunk in orig_db.pixels.chunks_exact(4) {
        o_alpha_counts[chunk[3] as usize] += 1;
    }
    println!("  Alpha distribution (0, 1..254, 255): {}, {}, {}", 
        o_alpha_counts[0], 
        o_alpha_counts[1..255].iter().sum::<usize>(), 
        o_alpha_counts[255]
    );

    println!("=== Saved D&B layer ===");
    println!("  Width: {}, Height: {}", saved_db.width, saved_db.height);
    println!("  Pixel buffer len: {}", saved_db.pixels.len());
    println!("  Mask bounds: {:?}", saved_db.mask_bounds);
    println!("  Mask default color: {}", saved_db.mask_default_color);
    if let Some(ref mask) = saved_db.mask_pixels {
        println!("  Mask pixels len: {}", mask.len());
        let mut zero_count = 0;
        let mut non_zero_count = 0;
        for &v in mask {
            if v == 0 { zero_count += 1; } else { non_zero_count += 1; }
        }
        println!("  Mask pixels (0 vs non-zero): {} vs {}", zero_count, non_zero_count);
    } else {
        println!("  No mask pixels");
    }
    let mut s_alpha_counts = [0usize; 256];
    for chunk in saved_db.pixels.chunks_exact(4) {
        s_alpha_counts[chunk[3] as usize] += 1;
    }
    println!("  Alpha distribution (0, 1..254, 255): {}, {}, {}", 
        s_alpha_counts[0], 
        s_alpha_counts[1..255].iter().sum::<usize>(), 
        s_alpha_counts[255]
    );

    // Dump raw mask data bytes
    println!("\n=== Raw Mask Section Comparison ===");
    dump_raw_mask_bytes("Original", orig_path);
    dump_raw_mask_bytes("Saved", saved_path);
}

fn dump_raw_mask_bytes(label: &str, path: &Path) {
    let bytes = std::fs::read(path).unwrap();
    let mut r = hcie_psd::psd_reader::PsdReader::new(&bytes);
    r.read(26).unwrap();
    let color_mode_len = r.read_u32().unwrap() as usize;
    r.read(color_mode_len).unwrap();
    let img_res_len = r.read_u32().unwrap() as usize;
    r.read(img_res_len).unwrap();
    let _lmi_len = r.read_u32().unwrap();
    let _li_len = r.read_u32().unwrap();
    let layer_count_raw = r.read_i16().unwrap();
    let layer_count = layer_count_raw.abs() as usize;

    let mut layers_meta = Vec::new();
    for _ in 0..layer_count {
        let _top = r.read_i32().unwrap();
        let _left = r.read_i32().unwrap();
        let _bottom = r.read_i32().unwrap();
        let _right = r.read_i32().unwrap();
        let channel_count = r.read_u16().unwrap() as usize;
        for _ in 0..channel_count {
            let _id = r.read_i16().unwrap();
            let _len = r.read_u32().unwrap();
        }
        r.read(4).unwrap(); // sig
        r.read(4).unwrap(); // blend
        r.read_u8().unwrap(); // opacity
        r.read_u8().unwrap(); // clipping
        r.read_u8().unwrap(); // flags
        r.read(1).unwrap(); // filler
        
        let extra_data_len = r.read_u32().unwrap() as usize;
        let start = r.pos();
        let mask_len = r.read_u32().unwrap() as usize;
        let mask_bytes = r.read(mask_len).unwrap().to_vec();
        r.read(extra_data_len - 4 - mask_len).unwrap(); // skip rest of extra data

        // read name to find layer
        let mut sub_r = hcie_psd::psd_reader::PsdReader::new(&bytes[start + 4 + mask_len..]);
        let _blending_ranges_len = sub_r.read_u32().unwrap() as usize;
        sub_r.read(_blending_ranges_len).unwrap();
        let name_len = sub_r.read_u8().unwrap() as usize;
        let name_bytes = sub_r.read(name_len).unwrap();
        let name = String::from_utf8_lossy(name_bytes).to_string();

        layers_meta.push((name, mask_len, mask_bytes));
    }

    if let Some((name, mask_len, mask_bytes)) = layers_meta.iter().find(|(name, _, _)| name == "D&B with Retouch4me") {
        println!("{}: Layer '{}' mask_len={} bytes={:?}", label, name, mask_len, mask_bytes);
    } else {
        println!("{}: D&B with Retouch4me layer not found", label);
    }
}