// Scratch: decoded-space run dump. Deleted after run.
use std::collections::HashMap;
use nigig_pdf_cos::PdfObj;
use nigig_pdf_graphics::content::parse_content_stream;
use nigig_pdf_graphics::recording::{RecordingDevice, RenderCommand};
use nigig_pdf_graphics::transparency::resolve_page_ext_gstates;
use nigig_pdf_graphics::font::build_font_from_dict;
use nigig_pdf_graphics::colorspace::resolve_page_color_spaces;

#[test]
fn probe() {
    let path = "/Users/aok/Projects/rustdev/CratesCode/dart-pdf/test_corpora/ghent/2-SPOT/GWG030_Gray_K_black_OP_X1.pdf";
    let bytes = std::fs::read(path).expect("fixture");
    let mut doc = nigig_pdf_document::PdfDocument::parse(&bytes).expect("parses");
    let page = doc.page(0).expect("page");
    let content = page.content_data.clone();
    let page_ref = doc.page_object_ref(0).expect("ref");
    let page_obj = doc.resolve_ref(page_ref).expect("obj");
    let resources = doc.resolve(page_obj.as_dict().expect("d").get("Resources").expect("res")).expect("res2");
    let res = resources.as_dict().expect("dict").clone();
    let mut device = RecordingDevice::new();
    if let Some(fonts) = res.get("Font") {
        if let Ok(fdict) = doc.resolve(fonts) {
            if let Some(fdict) = fdict.as_dict() {
                for (name, fobj) in fdict.map.iter() {
                    if let Ok(f) = doc.resolve(fobj) {
                        if let Some(fd) = f.as_dict() {
                            let mut r = |o: &PdfObj| doc.resolve(o);
                            if let Ok(info) = build_font_from_dict(fd, &mut r) {
                                device.font_widths.insert(name.clone(), info.widths);
                            }
                        }
                    }
                }
            }
        }
    }
    let mut n_space_ok = 0; let mut n_space_err = 0;
    let map: HashMap<String, PdfObj> = page.color_spaces.clone();
    for (name, space) in resolve_page_color_spaces(&map) {
        match space {
            Ok(s) => { n_space_ok += 1; device.register_color_space(&name, s); }
            Err(e) => { n_space_err += 1; eprintln!("space {name} ERR {e:?}"); }
        }
    }
    eprintln!("spaces ok={n_space_ok} err={n_space_err}");
    let (states, errs) = resolve_page_ext_gstates(&page.ext_gstates);
    eprintln!("gstates={} errs={}", states.len(), errs.len());
    for (name, state) in states {
        device.register_ext_gstate(&name, state);
    }
    let ops = parse_content_stream(&content).expect("ops");
    nigig_pdf_graphics::content::interpret_ops(&ops, &mut device).expect("interpret");
    eprintln!("color_errors={}", device.color_errors().len());
    for e in device.color_errors().iter().take(4) { eprintln!("  cerr {e:?}"); }
    let mut fill_op = false; let mut saved = vec![]; let mut color = [0.0,0.0,0.0,1.0];
    let mut n_text = 0; let mut n_flag = 0;
    for c in &device.commands {
        match c {
            RenderCommand::Save => saved.push(fill_op),
            RenderCommand::Restore => { fill_op = saved.pop().unwrap_or(false); }
            RenderCommand::SetOverprint { fill, .. } => fill_op = *fill,
            RenderCommand::SetFillColor(col) => color = *col,
            RenderCommand::ShowTextWithMetrics { decoded, .. } => {
                n_text += 1;
                if fill_op { n_flag += 1; if n_flag <= 8 { eprintln!("flag text {decoded:?} color={color:?}"); } }
            }
            _ => {}
        }
    }
    eprintln!("texts={n_text} flag={n_flag}");
    panic!("show");
}