#![allow(dead_code, unused_imports, unused_variables, unused_macros, unreachable_patterns)]

fn main() {
    let orig_bytes = std::fs::read("_images/_psd_stil_test/inner_shadow/black_triangle_green_inner_shadow_normal_blend.psd").unwrap();
    let saved_bytes = std::fs::read("_tmp/roundtrip_output.psd").unwrap();

    // Extract lfx2 block from Layer 1 (Black Triangle) of both files
    println!("=== LFX2 BLOCK COMPARISON ===\n");

    let orig_lfx2 = extract_block(&orig_bytes, "lfx2", 1);
    let saved_lfx2 = extract_block(&saved_bytes, "lfx2", 1);

    match (&orig_lfx2, &saved_lfx2) {
        (Some(o), Some(s)) => {
            println!("ORIG lfx2: {} bytes", o.len());
            println!("SAVED lfx2: {} bytes", s.len());
            println!("Diff: {} bytes", o.len() as i64 - s.len() as i64);

            // Byte-by-byte diff
            let min_len = o.len().min(s.len());
            for i in 0..min_len {
                if o[i] != s[i] {
                    println!("  FIRST DIFF at byte {}: orig=0x{:02X} saved=0x{:02X}", i, o[i], s[i]);
                    let start = i.saturating_sub(16);
                    let end = (i + 48).min(min_len);
                    println!("  ORIG : {}", hex_dump(&o[start..end]));
                    println!("  SAVED: {}", hex_dump(&s[start..end]));

                    // Also show as much descriptor text as possible
                    println!("\n  ORIG context (text): {}", text_view(&o[start..end]));
                    println!("  SAVED context (text): {}", text_view(&s[start..end]));
                    break;
                }
            }
            if o.len() != s.len() {
                // Show last 32 bytes of each
                println!("\n  ORIG tail (last 32): {}", hex_dump(&o[o.len().saturating_sub(32)..]));
                println!("  SAVED tail (last 32): {}", hex_dump(&s[s.len().saturating_sub(32)..]));
            }
        }
        (Some(o), None) => println!("ORIG has lfx2 ({} bytes), SAVED missing", o.len()),
        (None, Some(s)) => println!("SAVED has lfx2 ({} bytes), ORIG missing", s.len()),
        (None, None) => println!("Neither has lfx2"),
    }

    // Extract shmd block from Layer 1
    println!("\n=== SHMD BLOCK COMPARISON ===\n");
    let orig_shmd = extract_block(&orig_bytes, "shmd", 1);
    let saved_shmd = extract_block(&saved_bytes, "shmd", 1);

    match (&orig_shmd, &saved_shmd) {
        (Some(o), Some(s)) => {
            println!("ORIG shmd: {} bytes", o.len());
            println!("SAVED shmd: {} bytes", s.len());

            let min_len = o.len().min(s.len());
            for i in 0..min_len {
                if o[i] != s[i] {
                    println!("  FIRST DIFF at byte {}: orig=0x{:02X} saved=0x{:02X}", i, o[i], s[i]);
                    let start = i.saturating_sub(16);
                    let end = (i + 48).min(min_len);
                    println!("  ORIG : {}", hex_dump(&o[start..end]));
                    println!("  SAVED: {}", hex_dump(&s[start..end]));
                    break;
                }
            }
        }
        _ => println!("Missing shmd in one or both"),
    }

    // Extract full Layer 1 extra data
    println!("\n=== LAYER 1 FULL EXTRA DATA COMPARISON ===\n");
    let orig_extra = extract_layer_extra(&orig_bytes, 1);
    let saved_extra = extract_layer_extra(&saved_bytes, 1);

    match (&orig_extra, &saved_extra) {
        (Some(o), Some(s)) => {
            println!("ORIG extra: {} bytes", o.len());
            dump_extra_blocks("ORIG", o);
            println!("\nSAVED extra: {} bytes", s.len());
            dump_extra_blocks("SAVED", s);
        }
        _ => println!("Could not extract extra data"),
    }
}

fn extract_block(bytes: &[u8], key: &str, _layer_idx: usize) -> Option<Vec<u8>> {
    let lmi = get_lmi(bytes)?;
    let li_len = u32::from_be_bytes([lmi[0], lmi[1], lmi[2], lmi[3]]) as usize;
    let li = &lmi[4..4+li_len];
    let layer_count = i16::from_be_bytes([li[0], li[1]]).unsigned_abs() as usize;

    let mut pos = 2;
    for _ in 0..layer_count {
        if pos + 18 > li.len() { return None; }
        let ch_count = u16::from_be_bytes([li[pos+16], li[pos+17]]) as usize;
        pos += 18;
        pos += ch_count * 6;
        if pos + 12 > li.len() { return None; }
        pos += 12; // blend+opacity+clipping+flags+filler
        let extra_len = u32::from_be_bytes([li[pos], li[pos+1], li[pos+2], li[pos+3]]) as usize;
        pos += 4;
        let _extra_start = pos;
        let extra_end = pos + extra_len;

        // Skip mask and blending ranges
        if pos + 4 > extra_end { return None; }
        let mask_len = u32::from_be_bytes([li[pos], li[pos+1], li[pos+2], li[pos+3]]) as usize;
        pos += 4 + mask_len;
        if pos + 4 > extra_end { return None; }
        let blend_len = u32::from_be_bytes([li[pos], li[pos+1], li[pos+2], li[pos+3]]) as usize;
        pos += 4 + blend_len;
        // Skip name
        if pos >= extra_end { return None; }
        let name_len = li[pos] as usize;
        pos += 1 + name_len;
        let bytes_mod_4 = (name_len + 1) % 4;
        pos += (4 - bytes_mod_4) % 4;

        // Scan for target block
        while pos + 8 <= extra_end {
            let sig = &li[pos..pos+4];
            if sig != b"8BIM" && sig != b"8B64" { break; }
            let block_key = String::from_utf8_lossy(&li[pos+4..pos+8]);
            let block_len = u32::from_be_bytes([li[pos+8], li[pos+9], li[pos+10], li[pos+11]]) as usize;
            if block_key == key {
                return Some(li[pos+12..pos+12+block_len].to_vec());
            }
            pos += 12 + block_len;
            if block_len % 2 != 0 { pos += 1; }
        }

        pos = extra_end;
    }
    None
}

fn extract_layer_extra(bytes: &[u8], layer_idx: usize) -> Option<Vec<u8>> {
    let lmi = get_lmi(bytes)?;
    let li_len = u32::from_be_bytes([lmi[0], lmi[1], lmi[2], lmi[3]]) as usize;
    let li = &lmi[4..4+li_len];
    let layer_count = i16::from_be_bytes([li[0], li[1]]).unsigned_abs() as usize;

    let mut pos = 2;
    for i in 0..layer_count {
        if pos + 18 > li.len() { return None; }
        let ch_count = u16::from_be_bytes([li[pos+16], li[pos+17]]) as usize;
        pos += 18;
        pos += ch_count * 6;
        if pos + 12 > li.len() { return None; }
        pos += 12;
        let extra_len = u32::from_be_bytes([li[pos], li[pos+1], li[pos+2], li[pos+3]]) as usize;
        pos += 4;
        let extra_start = pos;

        if i == layer_idx {
            return Some(li[extra_start..extra_start+extra_len].to_vec());
        }
        pos += extra_len;
    }
    None
}

fn dump_extra_blocks(_label: &str, extra: &[u8]) {
    let mut pos = 0;
    // Skip mask
    if pos + 4 > extra.len() { return; }
    let mask_len = u32::from_be_bytes([extra[pos], extra[pos+1], extra[pos+2], extra[pos+3]]) as usize;
    println!("  mask_data: {} bytes", mask_len);
    pos += 4 + mask_len;

    // Skip blending ranges
    if pos + 4 > extra.len() { return; }
    let blend_len = u32::from_be_bytes([extra[pos], extra[pos+1], extra[pos+2], extra[pos+3]]) as usize;
    println!("  blend_ranges: {} bytes", blend_len);
    pos += 4 + blend_len;

    // Name
    if pos >= extra.len() { return; }
    let name_len = extra[pos] as usize;
    pos += 1;
    if pos + name_len > extra.len() { return; }
    let name = String::from_utf8_lossy(&extra[pos..pos+name_len]);
    println!("  name: '{}' ({} bytes + padding)", name, name_len);
    pos += name_len;
    let bytes_mod_4 = (name_len + 1) % 4;
    pos += (4 - bytes_mod_4) % 4;

    // Tagged blocks
    while pos + 8 <= extra.len() {
        let sig = &extra[pos..pos+4];
        if sig != b"8BIM" && sig != b"8B64" {
            println!("  BAD SIG at {}: {:02X?}", pos, &extra[pos..pos+4.min(extra.len()-pos)]);
            break;
        }
        let key = String::from_utf8_lossy(&extra[pos+4..pos+8]);
        let block_len = u32::from_be_bytes([extra[pos+8], extra[pos+9], extra[pos+10], extra[pos+11]]) as usize;
        println!("  block '{}' len={} @{}", key, block_len, pos);
        pos += 12 + block_len;
        if block_len % 2 != 0 { pos += 1; }
    }
}

fn get_lmi(bytes: &[u8]) -> Option<&[u8]> {
    let cmd_len = u32::from_be_bytes([bytes[26], bytes[27], bytes[28], bytes[29]]) as usize;
    let ir_start = 30 + cmd_len;
    let ir_len = u32::from_be_bytes([bytes[ir_start], bytes[ir_start+1], bytes[ir_start+2], bytes[ir_start+3]]) as usize;
    let lmi_start = ir_start + 4 + ir_len;
    let lmi_len = u32::from_be_bytes([bytes[lmi_start], bytes[lmi_start+1], bytes[lmi_start+2], bytes[lmi_start+3]]) as usize;
    Some(&bytes[lmi_start+4..lmi_start+4+lmi_len])
}

fn hex_dump(data: &[u8]) -> String {
    data.iter().take(64).map(|b| format!("{:02X}", b)).collect::<Vec<_>>().join(" ")
}

fn text_view(data: &[u8]) -> String {
    data.iter().map(|&b| if b >= 0x20 && b < 0x7F { b as char } else { '.' }).collect()
}