use photocraft_color::{Color, PixelFormat, SampleType};
use photocraft_doc::TextLayer;
use photocraft_doc::text::{AntiAlias, Caps, CharStyle, FontFeature, Orientation, ParagraphRun, ParagraphStyle, TextAlign, TextDirection, TextRun, TextShape};
use photocraft_geom::Affine;

use crate::{TextEngine, fonts};

fn point(text: &str, size_pt: f32) -> TextLayer {
    TextLayer { text: text.into(), font_family: "Inter".into(), size_pt, ..Default::default() }
}

fn styled(text: &str, style: CharStyle) -> TextLayer {
    TextLayer { text: text.into(), runs: vec![TextRun { len: text.len(), style }], ..Default::default() }
}

#[test]
fn glyph_source_ranges_follow_shaped_clusters() {
    let mut engine = TextEngine::new();
    for text in ["office", "Aé B", "First\nSecond"] {
        let layer = point(text, 24.0);
        let layout = engine.layout(&layer, 72.0);
        assert!(!layout.glyphs.is_empty());
        assert_eq!(layout.glyphs.len(), layout.glyph_ranges.len());
        for range in &layout.glyph_ranges {
            assert!(range.start < range.end, "empty range in {text:?}");
            assert!(text.get(range.clone()).is_some(), "invalid range {range:?} in {text:?}");
            assert!(layout.clusters.iter().any(|cluster| cluster.range == *range), "missing cluster for {range:?}");
        }
    }
}

/// The rasteriser's pixel stages — composing one colour's coverage, unpremultiplying it, and
/// converting the tiles — are per pixel: no pixel reads a slot another pixel wrote. Spreading them
/// over threads therefore has to leave every byte as it was, which a one-thread pool checks.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn parallel_raster_matches_a_single_thread() {
    let one = rayon::ThreadPoolBuilder::new().num_threads(1).build().expect("one-thread pool");
    let mut e = TextEngine::new();
    let boxed = TextShape::Box { x: 0.0, y: 0.0, width: 220.0, height: 90.0 };
    let paragraph = TextLayer {
        text: "A paragraph box that wraps over several lines and covers many tiles, so the whole raster is exercised.".into(),
        font_family: "Inter".into(),
        size_pt: 18.0,
        shape: boxed,
        ..Default::default()
    };
    let no_aa = TextLayer { text: "No AA edge".into(), font_family: "Inter".into(), size_pt: 30.0, antialias: AntiAlias::None, ..Default::default() };
    let cases: Vec<(TextLayer, f32, PixelFormat)> = vec![
        (point("Parallel", 48.0), 72.0, PixelFormat::RGBA8),
        (styled("Bold italic", CharStyle { size_pt: 40.0, faux_bold: true, faux_italic: true, ..Default::default() }), 300.0, PixelFormat::RGBA8),
        (no_aa, 150.0, PixelFormat::RGBA16),
        (styled("Wide gamut", CharStyle { size_pt: 36.0, color: Color::rgba(2.5, -0.25, 0.5, 0.4), ..Default::default() }), 96.0, PixelFormat::RGBA32F),
        (with_para(paragraph, ParagraphStyle::default()), 144.0, PixelFormat::RGBA8),
    ];
    for (layer, dpi, format) in cases {
        let (_, spread) = e.render(&layer, dpi, format);
        let (_, single) = one.install(|| e.render(&layer, dpi, format));
        assert_eq!(spread.rect, single.rect, "{}", layer.text);
        assert_eq!(spread.surface, single.surface, "{}", layer.text);
    }
}

#[test]
fn raster_preserves_hdr_and_signed_float_text_colors() {
    let mut e = TextEngine::new();
    for alpha in [1.0, 0.4] {
        let color = Color::rgba(2.5, -0.25, 0.5, alpha);
        let style = CharStyle { size_pt: 48.0, color, ..Default::default() };
        let (_, rendered) = e.render(&styled("HDR", style), 72.0, PixelFormat::RGBA32F);
        let pixels = rendered.surface.read_region(rendered.rect);
        let mut covered = 0;
        for pixel in pixels.as_chunks::<4>().0.iter().filter(|p| p[3] > 0.01) {
            covered += 1;
            for channel in 0..3 {
                assert!((pixel[channel] - color.c[channel]).abs() < 1e-5, "alpha={alpha}, pixel={pixel:?}");
            }
            assert!(pixel[3] <= alpha + 1e-6);
        }
        assert!(covered > 100);
    }
}

#[test]
fn raster_integer_text_colors_stay_bounded() {
    let mut e = TextEngine::new();
    for format in [PixelFormat::RGBA8, PixelFormat::RGBA16] {
        let style = CharStyle { size_pt: 48.0, color: Color::rgba(2.5, -0.25, 0.5, 0.4), ..Default::default() };
        let (_, rendered) = e.render(&styled("HDR", style), 72.0, format);
        let pixels = rendered.surface.read_region(rendered.rect);
        let mut covered = 0;
        for pixel in pixels.as_chunks::<4>().0.iter().filter(|p| p[3] > 0.01) {
            covered += 1;
            assert_eq!(&pixel[..2], &[1.0, 0.0]);
            assert!((pixel[2] - 0.5).abs() < 1.0 / 255.0);
            assert!(pixel[3] <= 0.4 + 1.0 / 255.0);
        }
        assert!(covered > 100);
    }
}

fn with_para(mut t: TextLayer, p: ParagraphStyle) -> TextLayer {
    t.paragraphs = vec![ParagraphRun { len: t.text.len(), style: p }];
    t
}

fn width(l: &crate::TextLayout) -> f32 {
    l.lines.iter().map(|l| l.x1 - l.x0).fold(0.0, f32::max)
}

fn alpha_sum(s: &photocraft_raster::Surface, r: photocraft_geom::Rect) -> f64 {
    let n = s.channels();
    s.read_region(r).chunks_exact(n).map(|p| f64::from(p[n - 1])).sum()
}

#[test]
fn bundled_fonts_cover_latin() {
    let mut e = TextEngine::new();
    let fams = e.fonts.families();
    assert!(fams.iter().any(|f| f == "Inter"), "{fams:?}");
    assert!(fams.iter().any(|f| f == "JetBrains Mono"), "{fams:?}");
    let l = e.layout(&point("Hello, Wörld! 0123", 12.0), 72.0);
    assert_eq!(l.glyphs.len(), "Hello, Wörld! 0123".chars().count());
    assert!(l.glyphs.iter().all(|g| g.id != 0), "no .notdef");
    assert_eq!(e.fonts.faces("Inter").len(), 3);
}

#[test]
fn registering_fonts_moves_the_generation() {
    let mut e = TextEngine::new();
    let g = fonts::generation();
    e.fonts.register_font_data(fonts::INTER_REGULAR.to_vec());
    assert!(fonts::generation() > g);
}

/// Font menus cache on the shared engine's generation: other engines registering fonts (a test's
/// throwaway one, in parallel) must not invalidate them, or the menus re-render every frame.
#[test]
fn only_the_shared_database_moves_the_shared_generation() {
    let _ = crate::shared();
    let g = fonts::shared_generation();
    TextEngine::new().fonts.register_font_data(fonts::INTER_REGULAR.to_vec());
    assert_eq!(fonts::shared_generation(), g, "an unrelated engine leaves it alone");
    let mut e = TextEngine::new();
    e.fonts.mark_shared();
    let g = fonts::shared_generation();
    e.fonts.register_font_data(fonts::INTER_REGULAR.to_vec());
    assert!(fonts::shared_generation() > g);
}

#[test]
fn literal_psd_tabs_shape_as_whitespace_without_shifting_text_offsets() {
    let mut e = TextEngine::new();
    let src = "A\tB";
    let l = e.layout(&point(src, 20.0), 72.0);
    let plain = e.layout(&point("AB", 20.0), 72.0);
    assert_eq!(l.lines.len(), 1);
    assert!(l.glyphs.iter().all(|g| g.id != 0), "a tab must not render a tofu glyph");
    assert!(width(&l) > width(&plain), "the tab reserves whitespace");
    assert!(l.clusters.iter().all(|c| c.range.end <= src.len()), "the source byte offsets stay valid");
    assert!(l.caret(2).0 > l.caret(1).0, "caret moves across the tab");
}

/// Pen position of the cluster starting at byte `at`.
fn cluster_x(l: &crate::TextLayout, at: usize) -> f32 {
    l.clusters.iter().find(|c| c.range.start == at).map(|c| c.x).unwrap()
}

/// #1881: a tab advances to Photoshop's next default tab stop (every 36 pt, from the anchor or
/// the box's left edge), not one space width.
#[test]
fn tabs_advance_to_the_next_default_tab_stop() {
    let mut e = TextEngine::new();
    let near = |a: f32, b: f32| (a - b).abs() < 0.05;
    let l = e.layout(&point("a\tb", 20.0), 72.0);
    assert!(l.glyphs.iter().all(|g| g.id != 0), "no .notdef");
    assert!(near(cluster_x(&l, 2), 36.0), "{}", cluster_x(&l, 2));
    assert!(near(l.caret(2).0, 36.0), "the caret after the tab sits on the stop");
    // Stops are in points: twice the pixels at 144 dpi.
    let l = e.layout(&point("a\tb", 20.0), 144.0);
    assert!(near(cluster_x(&l, 2), 72.0), "{}", cluster_x(&l, 2));
    // Each tab moves to the following stop; text past a stop skips to the next one.
    let l = e.layout(&point("a\t\tb", 20.0), 72.0);
    assert!(near(cluster_x(&l, 3), 72.0), "{}", cluster_x(&l, 3));
    let l = e.layout(&point("MMM\tb", 20.0), 72.0);
    assert!(cluster_x(&l, 3) > 36.0);
    assert!(near(cluster_x(&l, 4), 72.0), "{}", cluster_x(&l, 4));
    // A tab at the start of a line goes to the first stop; the line extent includes it.
    let l = e.layout(&point("\tb", 20.0), 72.0);
    assert!(near(cluster_x(&l, 1), 36.0), "{}", cluster_x(&l, 1));
    assert!(l.lines[0].x1 > 36.0);
    // Paragraph text measures from the box's left edge.
    let mut t = point("a\tb", 20.0);
    t.shape = TextShape::Box { x: 10.0, y: 0.0, width: 300.0, height: 100.0 };
    let l = e.layout(&t, 72.0);
    assert!(near(cluster_x(&l, 2), 46.0), "{}", cluster_x(&l, 2));
}

/// The tab stays a tab in the document: PSD type round-trips it unchanged.
#[test]
fn psd_round_trips_tabs() {
    for shape in [TextShape::Point, TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 100.0 }] {
        let t = TextLayer { shape: shape.clone(), ..point("Name\tValue\n\tIndented", 20.0) };
        let back = crate::psd::text_layer_from_tysh(&crate::psd::build_tysh(&t, 72.0, None), 72.0).unwrap();
        assert_eq!(back.text, t.text, "{shape:?}");
    }
}

/// Expanded tabs never push paragraph text past the box's right edge.
#[test]
fn tabs_wrap_inside_the_box() {
    let mut e = TextEngine::new();
    let mut t = point("a\tb\tc\td\te\tf\tg", 20.0);
    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 100.0, height: 1000.0 };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() > 1, "{}", l.lines.len());
    // Lines break at the real tab widths: "c" (stop 72 px) still fits, "d" (stop 108 px) wraps.
    let line_of = |at: usize| l.clusters.iter().find(|c| c.range.start == at).map(|c| c.line).unwrap();
    assert_eq!((line_of(4), line_of(6)), (0, 1));
    assert!((cluster_x(&l, 6) - 0.0).abs() < 0.05, "a wrapped line starts at the box edge");
    for c in &l.clusters {
        let ch = &t.text[c.range.clone()];
        if ch != "\t" {
            assert!(c.x + c.advance <= 100.0 + 1e-3, "{ch:?} at {} overflows", c.x);
        }
    }
}

/// Right-aligned and centred point text keep their alignment around the expanded tab.
#[test]
fn tabs_keep_point_text_alignment() {
    let mut e = TextEngine::new();
    let r = e.layout(&with_para(point("a\tb", 20.0), ParagraphStyle { align: TextAlign::Right, ..Default::default() }), 72.0);
    assert!(r.lines[0].x1.abs() < 0.05, "{:?}", r.lines[0]);
    let b = r.clusters.iter().find(|c| c.range.start == 2).unwrap();
    assert!((b.x + b.advance).abs() < 0.05, "b ends at the anchor: {b:?}");
    assert!(r.lines[0].x0 < -36.0);
    // Paragraph text: the line still ends at the box's right edge; a trailing tab is
    // whitespace outside the line's extent.
    for text in ["a\tb", "a\tb\t"] {
        let t = with_para(
            TextLayer { shape: TextShape::Box { x: 0.0, y: 0.0, width: 200.0, height: 100.0 }, ..point(text, 20.0) },
            ParagraphStyle { align: TextAlign::Right, ..Default::default() },
        );
        let l = e.layout(&t, 72.0);
        let b = l.clusters.iter().find(|c| c.range.start == 2).unwrap();
        assert!((b.x + b.advance - 200.0).abs() < 0.5, "{text:?}: {b:?}");
        assert!((l.lines[0].x1 - 200.0).abs() < 0.5, "{text:?}: {:?}", l.lines[0]);
    }
}

#[test]
fn metrics_are_stable_and_scale_with_dpi() {
    let mut e = TextEngine::new();
    let a = e.layout(&point("Hamburgefonstiv", 12.0), 72.0);
    let w = width(&a);
    // Inter 12 px: stable to a tenth of a pixel across runs.
    let again = width(&e.layout(&point("Hamburgefonstiv", 12.0), 72.0));
    assert_eq!(w, again);
    assert!((80.0..110.0).contains(&w), "{w}");
    let b = e.layout(&point("Hamburgefonstiv", 12.0), 144.0);
    assert!((width(&b) - 2.0 * w).abs() < 0.05, "{} vs {}", width(&b), 2.0 * w);
    // Point text: first baseline at the anchor.
    assert_eq!(a.lines[0].baseline, 0.0);
    assert!(a.lines[0].ascent > 8.0 && a.lines[0].ascent < 13.0);
}

#[test]
fn small_caps_are_synthesized_when_the_font_has_no_small_caps_feature() {
    let style = CharStyle { font_family: "Inter".into(), size_pt: 40.0, caps: Caps::SmallCaps, ..Default::default() };
    let mut engine = TextEngine::new();
    let small = engine.layout(&styled("aA", style), 72.0);
    let upper = engine.layout(&styled("AA", CharStyle { font_family: "Inter".into(), size_pt: 40.0, ..Default::default() }), 72.0);
    assert_eq!(small.glyphs.len(), 2);
    assert_eq!(small.glyphs[0].id, upper.glyphs[0].id, "lowercase uses the uppercase glyph");
    assert_eq!(small.glyphs[1].id, upper.glyphs[1].id, "uppercase remains uppercase");
    let size = |layout: &crate::TextLayout, glyph: usize| layout.faces[layout.glyphs[glyph].face as usize].size_px;
    assert!((size(&small, 0) - 28.0).abs() < 0.01, "{}", size(&small, 0));
    assert!((size(&small, 1) - 40.0).abs() < 0.01, "{}", size(&small, 1));
}

#[test]
fn auto_and_explicit_leading() {
    let mut e = TextEngine::new();
    let l = e.layout(&point("one\ntwo\rthree", 10.0), 72.0);
    assert_eq!(l.lines.len(), 3);
    assert!((l.lines[1].baseline - 12.0).abs() < 1e-3, "auto leading = 1.2 × size");
    assert!((l.lines[2].baseline - 24.0).abs() < 1e-3);
    assert_eq!(&"one\ntwo\rthree"[l.lines[2].range.clone()], "three");
    let t = styled("a\nb", CharStyle { size_pt: 10.0, leading_pt: Some(30.0), ..Default::default() });
    let l = e.layout(&t, 144.0);
    assert!((l.lines[1].baseline - 60.0).abs() < 1e-3, "{}", l.lines[1].baseline);
    // Space before/after in points.
    let t = with_para(point("a\nb", 10.0), ParagraphStyle { space_after_pt: 5.0, ..Default::default() });
    let l = e.layout(&t, 72.0);
    assert!((l.lines[1].baseline - 17.0).abs() < 1e-3, "{}", l.lines[1].baseline);
}

#[test]
fn box_text_wraps_inside_width() {
    let mut e = TextEngine::new();
    let mut t = point("The quick brown fox jumps over the lazy dog again and again", 12.0);
    t.shape = TextShape::Box { x: 10.0, y: 20.0, width: 100.0, height: 1000.0 };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 3, "{}", l.lines.len());
    for line in &l.lines {
        assert!(line.x0 >= 10.0 - 1e-3 && line.x1 <= 110.0 + 1e-3, "{line:?}");
    }
    // First baseline = top + ascender height ('d'), a bit less than the hhea ascent.
    let drop = l.lines[0].baseline - 20.0;
    assert!(drop > 0.65 * 12.0 && drop < l.lines[0].ascent, "{drop}");
    // Lines cover the text in order.
    assert_eq!(l.lines[0].range.start, 0);
    for w in l.lines.windows(2) {
        assert!(w[1].range.start >= w[0].range.end);
    }
    // Overflowing lines are hidden, like Photoshop.
    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 100.0, height: 30.0 };
    let l2 = e.layout(&t, 72.0);
    assert_eq!(l2.lines.len(), 2);
}

/// #5565: paragraph text breaks at its horizontally scaled width. At 60% it breaks like 100%
/// text in a box 1/0.6 as wide, and the lines fill the box instead of wrapping early.
#[test]
fn horizontal_scale_breaks_paragraph_lines_at_the_scaled_width() {
    let mut e = TextEngine::new();
    let text = "The quick brown fox jumps over the lazy dog again and again until the paragraph wraps";
    let boxed = |scale: f32, width: f32, align: TextAlign| {
        let style = CharStyle { font_family: "Inter".into(), size_pt: 12.0, horizontal_scale: scale, ..Default::default() };
        let t = TextLayer { shape: TextShape::Box { x: 10.0, y: 0.0, width, height: 1000.0 }, ..styled(text, style) };
        with_para(t, ParagraphStyle { align, ..Default::default() })
    };
    let ranges = |l: &crate::TextLayout| l.lines.iter().map(|ln| ln.range.clone()).collect::<Vec<_>>();
    for scale in [0.6f32, 1.5] {
        let scaled = e.layout(&boxed(scale, 120.0, TextAlign::Left), 72.0);
        let plain = e.layout(&boxed(1.0, 120.0 / scale, TextAlign::Left), 72.0);
        assert!(scaled.lines.len() > 1, "{scale}");
        assert_eq!(ranges(&scaled), ranges(&plain), "{scale}: same breaks as unscaled text in the widened box");
        for (li, ln) in scaled.lines.iter().enumerate() {
            assert!(ln.x0 >= 10.0 - 1e-3 && ln.x1 <= 130.0 + 1e-3, "{scale}: {ln:?}");
            // The extent ends at the last glyph, not after the scaled trailing space.
            let ink = scaled.clusters.iter().filter(|c| c.line == li && !text[c.range.clone()].trim().is_empty());
            assert!((ink.map(|c| c.x + c.advance).fold(0.0, f32::max) - ln.x1).abs() < 0.01, "{scale}: {ln:?}");
        }
    }
    // At 60% the lines use the box: the first would not fit at 100%.
    let scaled = e.layout(&boxed(0.6, 120.0, TextAlign::Left), 72.0);
    assert!(scaled.lines[0].x1 > 110.0, "{:?}", scaled.lines[0]);
    // Centred and right-aligned lines are placed by their scaled width.
    let c = e.layout(&boxed(0.6, 120.0, TextAlign::Center), 72.0);
    for ln in &c.lines {
        assert!(((ln.x0 + ln.x1) * 0.5 - 70.0).abs() < 0.5, "{ln:?}");
    }
    let r = e.layout(&boxed(0.6, 120.0, TextAlign::Right), 72.0);
    for ln in &r.lines {
        assert!((ln.x1 - 130.0).abs() < 0.5, "{ln:?}");
    }
}

#[test]
fn alignment_point_and_box() {
    let mut e = TextEngine::new();
    let c = e.layout(&with_para(point("Centered", 20.0), ParagraphStyle { align: TextAlign::Center, ..Default::default() }), 72.0);
    let ln = &c.lines[0];
    assert!((ln.x0 + ln.x1).abs() < 0.01, "centered on anchor: {ln:?}");
    let r = e.layout(&with_para(point("Right", 20.0), ParagraphStyle { align: TextAlign::Right, ..Default::default() }), 72.0);
    assert!(r.lines[0].x1.abs() < 0.01 && r.lines[0].x0 < -10.0);

    let mut t = point("aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk", 12.0);
    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 120.0, height: 500.0 };
    let t = with_para(t, ParagraphStyle { align: TextAlign::JustifyLeft, ..Default::default() });
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() > 1);
    let first = &l.lines[0];
    // Justified line: last glyph ends at the right edge (within a pixel).
    let last_glyph_x = l.glyphs.iter().filter(|g| (g.y - first.baseline).abs() < 1e-3).map(|g| g.x).fold(f32::MIN, f32::max);
    assert!(last_glyph_x > 110.0, "{last_glyph_x}");
    let right = with_para(
        TextLayer { shape: TextShape::Box { x: 0.0, y: 0.0, width: 200.0, height: 100.0 }, ..point("end", 12.0) },
        ParagraphStyle { align: TextAlign::Right, ..Default::default() },
    );
    let l = e.layout(&right, 72.0);
    assert!((l.lines[0].x1 - 200.0).abs() < 0.5, "{:?}", l.lines[0]);
}

#[test]
fn rtl_text_is_reordered() {
    let mut e = TextEngine::new();
    // Hebrew isn't in the bundled fonts, but bidi still resolves (glyphs may be .notdef).
    let text = "abc שלום def";
    let l = e.layout(&point(text, 12.0), 72.0);
    let heb: Vec<_> = l.clusters.iter().filter(|c| text[c.range.clone()].chars().all(|ch| ('\u{0590}'..='\u{05FF}').contains(&ch))).collect();
    assert_eq!(heb.len(), 4);
    assert!(heb.iter().all(|c| c.rtl));
    // Visual order: the first logical Hebrew letter is rightmost among them.
    let first = heb.iter().min_by_key(|c| c.range.start).unwrap();
    assert!(heb.iter().all(|c| c.x <= first.x + 1e-3));
    // Forced RTL paragraph: the Latin run ends up to the right of the Hebrew.
    let t = with_para(point("שלום abc", 12.0), ParagraphStyle { direction: TextDirection::Rtl, ..Default::default() });
    let l = e.layout(&t, 72.0);
    let a = l.clusters.iter().find(|c| &"שלום abc"[c.range.clone()] == "a").unwrap();
    let shin = l.clusters.iter().find(|c| c.range.start == 0).unwrap();
    assert!(a.x < shin.x, "abc left of the Hebrew in an RTL paragraph");
    assert!(l.clusters.iter().all(|c| c.range.end <= "שלום abc".len()));
}

/// Builds a TrueType collection from standalone fonts (table offsets rebased).
fn make_ttc(fonts: &[&[u8]]) -> Vec<u8> {
    let header_len = 12 + 4 * fonts.len();
    let mut out = Vec::new();
    out.extend_from_slice(b"ttcf");
    out.extend_from_slice(&0x0001_0000u32.to_be_bytes());
    out.extend_from_slice(&(fonts.len() as u32).to_be_bytes());
    let mut offsets = Vec::new();
    let mut body: Vec<u8> = Vec::new();
    for f in fonts {
        while !(header_len + body.len()).is_multiple_of(4) {
            body.push(0);
        }
        let base = (header_len + body.len()) as u32;
        offsets.push(base);
        let mut copy = f.to_vec();
        let n = u16::from_be_bytes([copy[4], copy[5]]) as usize;
        for i in 0..n {
            let at = 12 + i * 16 + 8;
            let off = u32::from_be_bytes(copy[at..at + 4].try_into().unwrap());
            copy[at..at + 4].copy_from_slice(&(off + base).to_be_bytes());
        }
        body.extend(copy);
    }
    for o in offsets {
        out.extend_from_slice(&o.to_be_bytes());
    }
    out.extend(body);
    out
}

#[test]
fn truetype_collections_load() {
    let ttc = make_ttc(&[fonts::BUNDLED[0].1.as_slice(), fonts::BUNDLED[3].1.as_slice()]);
    assert_eq!(fonts::face_count(&ttc), 2);
    let mut db = fonts::FontDb::new();
    // A fresh DB without the bundled mono font would miss it; register the collection anyway
    // and check both faces are indexed (families already present gain faces).
    let before = db.faces("JetBrains Mono").len();
    let names = db.register_font_data(ttc);
    assert!(names.iter().any(|n| n == "Inter") && names.iter().any(|n| n == "JetBrains Mono"), "{names:?}");
    assert_eq!(db.faces("JetBrains Mono").len(), before + 1);
    // Layout with the TTC-backed face works.
    let mut e = TextEngine { fonts: db, layouter: crate::layout::Layouter::new() };
    let t = styled("mono", CharStyle { font_family: "JetBrains Mono".into(), ..Default::default() });
    let l = e.layout(&t, 72.0);
    assert!(l.glyphs.iter().all(|g| g.id != 0));
}

#[test]
fn opentype_features_and_tracking() {
    let mut e = TextEngine::new();
    let ids = |e: &mut TextEngine, feats: Vec<FontFeature>, lig: bool| {
        let t = styled("a0", CharStyle { features: feats, ligatures: lig, ..Default::default() });
        e.layout(&t, 72.0).glyphs.iter().map(|g| g.id).collect::<Vec<_>>()
    };
    let plain = ids(&mut e, vec![], true);
    let alt = ids(&mut e, vec![FontFeature { tag: "zero".into(), value: 1 }], true);
    assert_ne!(plain, alt, "Inter's `zero` feature selects the slashed zero");
    let a = width(&e.layout(&styled("tracking", CharStyle::default()), 72.0));
    let b = width(&e.layout(&styled("tracking", CharStyle { tracking: 100.0, ..Default::default() }), 72.0));
    // 100/1000 em at 12 px per letter (8 letters; trailing spacing counts too).
    assert!((b - a - 8.0 * 1.2).abs() < 1.3, "{a} → {b}");
}

#[test]
fn raster_coverage_scales_and_depths_agree() {
    let mut e = TextEngine::new();
    let t = |size: f32| TextLayer { transform: Affine::translate(10.0, 50.0), ..point("Ink", size) };
    let (_, r12) = e.render(&t(12.0), 72.0, PixelFormat::RGBA8);
    let (_, r24) = e.render(&t(24.0), 72.0, PixelFormat::RGBA8);
    let s12 = alpha_sum(&r12.surface, r12.rect);
    let s24 = alpha_sum(&r24.surface, r24.rect);
    assert!(s12 > 20.0, "{s12}");
    let ratio = s24 / s12;
    assert!((3.6..4.4).contains(&ratio), "ink ∝ size²: {ratio}");
    // Placement: anchored at (10, 50) baseline.
    assert!(r12.rect.x0 >= 8 && r12.rect.x0 <= 11 && r12.rect.y1 <= 53 && r12.rect.y1 >= 50, "{:?}", r12.rect);
    for fmt in [PixelFormat::RGBA16, PixelFormat::RGBA32F, PixelFormat::GRAYA8, PixelFormat::CMYKA8] {
        let (_, r) = e.render(&t(12.0), 72.0, fmt);
        assert_eq!(r.rect, r12.rect);
        let s = alpha_sum(&r.surface, r.rect);
        assert!((s - s12).abs() / s12 < 0.01, "{fmt:?}: {s} vs {s12}");
    }
    // Deterministic.
    let (_, again) = e.render(&t(12.0), 72.0, PixelFormat::RGBA8);
    assert_eq!(again.surface, r12.surface);
    // Golden-ish total ink for "Ink" in Inter 12 px (±3%).
    assert!((s12 - GOLDEN_INK_12).abs() / GOLDEN_INK_12 < 0.03, "ink sum {s12}");
}

/// Sum of alpha for "Ink", Inter Regular 12 px (measured once; guards rasterizer regressions).
const GOLDEN_INK_12: f64 = 44.4;

#[test]
fn styles_change_pixels() {
    let mut e = TextEngine::new();
    let base = CharStyle { size_pt: 30.0, ..Default::default() };
    let ink = |e: &mut TextEngine, s: CharStyle| {
        let (_, r) = e.render(&TextLayer { transform: Affine::translate(5.0, 40.0), ..styled("Hi", s) }, 72.0, PixelFormat::RGBA8);
        (alpha_sum(&r.surface, r.rect), r.rect)
    };
    let (plain, prect) = ink(&mut e, base.clone());
    let (bold, _) = ink(&mut e, CharStyle { faux_bold: true, ..base.clone() });
    assert!(bold > plain * 1.1, "{plain} → {bold}");
    let (under, urect) = ink(&mut e, CharStyle { underline: true, ..base.clone() });
    assert!(under > plain && urect.y1 > prect.y1);
    let (_, irect) = ink(&mut e, CharStyle { faux_italic: true, ..base.clone() });
    assert!(irect.x1 > prect.x1, "slanted top extends right");
    let (_, srect) = ink(&mut e, CharStyle { baseline_shift_pt: 10.0, ..base.clone() });
    assert_eq!(srect.y0, prect.y0 - 10);
    let (_, hrect) = ink(&mut e, CharStyle { horizontal_scale: 2.0, ..base.clone() });
    assert!(hrect.width() as f32 > prect.width() as f32 * 1.7);
}

/// #5645: superscript and subscript runs are drawn at 58.3% of their size, raised or lowered by
/// 33.3% of it, as Photoshop draws them; they used to be drawn as plain text.
#[test]
fn superscript_and_subscript_shrink_and_shift_the_run() {
    use photocraft_doc::text::FontBaseline;
    let mut e = TextEngine::new();
    let base = CharStyle { size_pt: 60.0, ..Default::default() };
    let rect = |e: &mut TextEngine, baseline: FontBaseline| {
        let (_, r) =
            e.render(&TextLayer { transform: Affine::translate(5.0, 100.0), ..styled("H", CharStyle { baseline, ..base.clone() }) }, 72.0, PixelFormat::RGBA8);
        r.rect
    };
    let plain = rect(&mut e, FontBaseline::Normal);
    let sup = rect(&mut e, FontBaseline::Superscript);
    let sub = rect(&mut e, FontBaseline::Subscript);
    // Scripts render at 58.3% of the size. The pixel-snapped bounds of the antialiased glyph land
    // within 2 px of the exact scaled height (measured: +2.2 / +1.2 px at 46 px plain height).
    let expect = plain.height() as f32 * 0.583;
    for r in [&sup, &sub] {
        assert!((r.height() as f32 - expect).abs() <= 2.5, "plain {plain:?}, scripted {r:?}");
    }
    // The cap's foot sits on the shifted baseline: 20 px (33.3% of 60) above or below.
    assert!((plain.y1 - sup.y1 - 20).abs() <= 2, "plain {plain:?}, superscript {sup:?}");
    assert!((sub.y1 - plain.y1 - 20).abs() <= 2, "plain {plain:?}, subscript {sub:?}");
}

/// #4130: Faux bold at 72 dpi looked pixelated because the offset copies were summed into one
/// coverage buffer, saturating every antialiased edge pixel. Edges must stay antialiased and the
/// ink must grow only by the dilation (about perimeter x radius), not by edge saturation.
#[test]
fn faux_bold_keeps_antialiased_edges_at_small_sizes() {
    let mut e = TextEngine::new();
    let base = CharStyle { size_pt: 12.0, ..Default::default() };
    let stats = |e: &mut TextEngine, s: CharStyle| {
        let (_, r) = e.render(&TextLayer { transform: Affine::translate(5.0, 20.0), ..styled("Bold Test", s) }, 72.0, PixelFormat::RGBA8);
        let (w, h) = (r.rect.width() as usize, r.rect.height() as usize);
        let mut partial = 0usize;
        for y in 0..h {
            for x in 0..w {
                let a = alpha_sum(
                    &r.surface,
                    photocraft_geom::Rect::new(r.rect.x0 + x as i32, r.rect.y0 + y as i32, r.rect.x0 + x as i32 + 1, r.rect.y0 + y as i32 + 1),
                );
                if a > 0.05 && a < 0.95 {
                    partial += 1;
                }
            }
        }
        (alpha_sum(&r.surface, r.rect), partial)
    };
    let (plain_ink, plain_partial) = stats(&mut e, base.clone());
    let (bold_ink, bold_partial) = stats(&mut e, CharStyle { faux_bold: true, ..base });
    assert!(bold_ink > plain_ink, "bold must add ink");
    // Weight: the old summed-coverage faux bold (before #4130) measured 282.7 total ink for this
    // text at 12 px (plain 138.0). The antialiased version must stay close to that weight.
    const MAIN_BOLD_INK: f64 = 282.7;
    assert!(bold_ink >= MAIN_BOLD_INK * 0.85, "stems too thin: {bold_ink} vs old {MAIN_BOLD_INK}");
    assert!(bold_ink <= MAIN_BOLD_INK * 1.15, "stems too heavy: {bold_ink} vs old {MAIN_BOLD_INK}");
    assert!(bold_partial * 10 >= plain_partial * 8, "edges stay antialiased: {plain_partial} -> {bold_partial}");
}

/// #3705: Faux bold dilation must scale with horizontal and vertical glyph scaling.
#[test]
fn faux_bold_scales_with_glyph_scaling() {
    let mut e = TextEngine::new();
    let base = CharStyle { size_pt: 40.0, ..Default::default() };
    let ink = |e: &mut TextEngine, s: CharStyle| {
        let (_, r) = e.render(&TextLayer { transform: Affine::translate(5.0, 50.0), ..styled("Hi", s) }, 72.0, PixelFormat::RGBA8);
        (alpha_sum(&r.surface, r.rect), r.rect)
    };
    let (_plain, prect) = ink(&mut e, base.clone());
    let (_bold, brect) = ink(&mut e, CharStyle { faux_bold: true, ..base.clone() });
    let unscaled_extra_w = brect.width() - prect.width();
    let unscaled_extra_h = brect.height() - prect.height();

    // With 2x horizontal scale, the horizontal dilation scales with the glyph:
    let hscaled = CharStyle { size_pt: 40.0, horizontal_scale: 2.0, ..Default::default() };
    let (_, phrect) = ink(&mut e, hscaled.clone());
    let (_, bhrect) = ink(&mut e, CharStyle { faux_bold: true, ..hscaled });
    let hscaled_extra_w = bhrect.width() - phrect.width();
    assert!(
        hscaled_extra_w >= unscaled_extra_w * 2 - 1 && hscaled_extra_w <= unscaled_extra_w * 2 + 1,
        "hscaled extra width {hscaled_extra_w} vs unscaled {unscaled_extra_w}"
    );

    // With 2x vertical scale, the vertical dilation scales with the glyph:
    let vscaled = CharStyle { size_pt: 40.0, vertical_scale: 2.0, ..Default::default() };
    let (_, pvrect) = ink(&mut e, vscaled.clone());
    let (_, bvrect) = ink(&mut e, CharStyle { faux_bold: true, ..vscaled });
    let vscaled_extra_h = bvrect.height() - pvrect.height();
    assert!(
        vscaled_extra_h >= unscaled_extra_h * 2 - 1 && vscaled_extra_h <= unscaled_extra_h * 2 + 1,
        "vscaled extra height {vscaled_extra_h} vs unscaled {unscaled_extra_h}"
    );
}

#[test]
fn multicolor_runs() {
    let mut e = TextEngine::new();
    let red = CharStyle { size_pt: 40.0, color: Color::rgb(1.0, 0.0, 0.0), ..Default::default() };
    let blue = CharStyle { color: Color::rgb(0.0, 0.0, 1.0), ..red.clone() };
    let t = TextLayer {
        text: "HH".into(),
        runs: vec![TextRun { len: 1, style: red }, TextRun { len: 1, style: blue }],
        transform: Affine::translate(0.0, 40.0),
        ..Default::default()
    };
    let (l, r) = e.render(&t, 72.0, PixelFormat::RGBA8);
    assert_eq!(l.glyphs.len(), 2);
    let px = r.surface.read_region(r.rect);
    let opaque: Vec<&[f32; 4]> = px.as_chunks::<4>().0.iter().filter(|p| p[3] > 0.99).collect();
    assert!(opaque.iter().any(|p| p[0] > 0.99 && p[2] < 0.01));
    assert!(opaque.iter().any(|p| p[2] > 0.99 && p[0] < 0.01));
    // CMYK target keeps colour in the document model.
    let (_, rc) = e.render(&t, 72.0, PixelFormat::CMYKA8);
    assert!(rc.surface.read_region(rc.rect).as_chunks::<5>().0.iter().any(|p| p[4] > 0.99 && p[1] > 0.9 && p[2] > 0.9));
}

#[test]
fn hit_test_and_caret() {
    let mut e = TextEngine::new();
    let l = e.layout(&point("abc\ndef", 20.0), 72.0);
    assert_eq!(l.hit_test(-5.0, -5.0), 0);
    assert_eq!(l.hit_test(1000.0, -5.0), 3);
    assert_eq!(l.hit_test(-5.0, 24.0), 4);
    let (x, top, bottom) = l.caret(1);
    assert!(x > 0.0 && top < 0.0 && bottom > 0.0);
    let (x2, ..) = l.caret(2);
    assert!(x2 > x);
    assert_eq!(l.caret(3).0, l.lines[0].x1);
}

#[test]
fn wrapped_and_forced_line_starts_use_the_following_line() {
    use crate::layout::{byte_index, line_edge, line_index};

    let mut engine = TextEngine::new();
    let mut wrapped = point("ab cd", 12.0);
    wrapped.shape = TextShape::Box { x: 0.0, y: 0.0, width: 20.0, height: 70.0 };
    let layout = engine.layout(&wrapped, 72.0);
    assert!(layout.lines.len() >= 2, "paragraph must wrap: {:?}", layout.lines);
    let boundary = layout.lines[1].range.start;
    assert_eq!(layout.lines[0].range.end, boundary);
    let index = wrapped.text[..boundary].chars().count();
    assert_eq!(line_index(&layout, byte_index(&wrapped.text, index)), 1);
    assert_eq!(line_edge(&layout, &wrapped.text, index, false), index);
    assert_eq!(line_edge(&layout, &wrapped.text, index, true), wrapped.text[..layout.lines[1].range.end].chars().count());
    // The previous line's right edge shares the caret index, but a click there
    // must still report the previous visual line.
    let first = &layout.lines[0];
    let (x, y) = layout.to_text(first.x1, first.baseline);
    assert_eq!(crate::layout::hit_char(&layout, &wrapped.text, x, y).1, 0);

    let text = "a\u{3}b";
    let forced = engine.layout(&point(text, 12.0), 72.0);
    assert_eq!(forced.lines.len(), 2);
    let start = forced.lines[1].range.start;
    let index = text[..start].chars().count();
    assert_eq!(line_index(&forced, start), 1);
    assert_eq!(line_edge(&forced, text, index, false), index);
    assert_eq!(line_edge(&forced, text, index, true), text.chars().count());

    // A normal paragraph break has distinct boundaries and retains its line.
    let text = "a\nb";
    let paragraph = engine.layout(&point(text, 12.0), 72.0);
    assert_eq!(line_index(&paragraph, paragraph.lines[0].range.end), 0);
    assert_eq!(line_index(&paragraph, paragraph.lines[1].range.start), 1);
    assert_eq!(line_index(&paragraph, text.len()), 1);
}

#[test]
fn empty_text_and_empty_lines() {
    let mut e = TextEngine::new();
    let l = e.layout(&point("", 12.0), 72.0);
    assert_eq!(l.lines.len(), 1);
    assert!(l.glyphs.is_empty());
    let l = e.layout(&point("a\n\nb", 12.0), 72.0);
    assert_eq!(l.lines.len(), 3);
    assert!((l.lines[2].baseline - 2.0 * 14.4).abs() < 1e-3);
    let (_, r) = e.render(&point("", 12.0), 72.0, PixelFormat::RGBA8);
    assert_eq!(r.rect.width(), 0);
}

/// U+0003 is a forced line break inside a paragraph (as PSD type stores Shift+Return): a new
/// line with the paragraph's leading and no paragraph spacing, never a missing-glyph box.
#[test]
fn forced_line_break_starts_a_line_in_the_same_paragraph() {
    let mut e = TextEngine::new();
    let text = "one\u{3}two";
    let spaced = ParagraphStyle { space_before_pt: 5.0, space_after_pt: 5.0, ..Default::default() };
    let l = e.layout(&with_para(point(text, 10.0), spaced.clone()), 72.0);
    assert_eq!(l.lines.len(), 2, "{:?}", l.lines);
    assert_eq!(text[l.lines[0].range.clone()].trim_end_matches('\u{3}'), "one");
    assert_eq!(&text[l.lines[1].range.clone()], "two");
    assert_eq!((l.lines[0].paragraph, l.lines[1].paragraph), (0, 0));
    assert!((l.lines[1].baseline - 12.0).abs() < 1e-3, "auto leading, no paragraph spacing: {}", l.lines[1].baseline);
    assert!(l.glyphs.iter().all(|g| g.id != 0), "no .notdef for the break");
    // A paragraph break in the same place adds the spacing.
    let p = e.layout(&with_para(point("one\ntwo", 10.0), spaced), 72.0);
    assert!((p.lines[1].baseline - 22.0).abs() < 1e-3, "{}", p.lines[1].baseline);
    // Centred lines are centred on their own, and box text breaks there too.
    let c = e.layout(&with_para(point("a\u{3}wide line", 20.0), ParagraphStyle { align: TextAlign::Center, ..Default::default() }), 72.0);
    assert_eq!(c.lines.len(), 2);
    assert!((c.lines[0].x0 + c.lines[0].x1).abs() < 0.01 && (c.lines[1].x0 + c.lines[1].x1).abs() < 0.01, "{:?}", c.lines);
    let mut b = point("short\u{3}next", 12.0);
    b.shape = TextShape::Box { x: 0.0, y: 0.0, width: 500.0, height: 500.0 };
    assert_eq!(e.layout(&b, 72.0).lines.len(), 2);
    // Rendered at every depth: two rows of ink, and nothing after the first line's text.
    for fmt in [PixelFormat::RGBA8, PixelFormat::RGBA16, PixelFormat::RGBA32F] {
        let (l, r) = e.render(&TextLayer { transform: Affine::translate(0.0, 40.0), ..point(text, 20.0) }, 72.0, fmt);
        let row = |i: usize| {
            let ln = &l.lines[i];
            photocraft_geom::Rect::new(-2, (ln.baseline - ln.ascent + 40.0) as i32, 200, (ln.baseline + 40.0) as i32)
        };
        assert!(alpha_sum(&r.surface, row(0)) > 1.0 && alpha_sum(&r.surface, row(1)) > 1.0, "{fmt:?}");
        let one_end = l.lines[0].x1.ceil() as i32 + 2;
        assert!(alpha_sum(&r.surface, photocraft_geom::Rect::new(one_end, row(0).y0, 200, row(0).y1)) < 1e-3, "{fmt:?}: ink after the first line's text");
    }
}

#[test]
fn hyphenated_postscript_names_preserve_family_prefixes() {
    for (ps, family, weight, italic) in
        [("FOT-NewRodinPro-Regular", "FOT-New Rodin Pro", 400, false), ("Vendor-FamilyPro-BoldIt", "Vendor-Family Pro", 700, true)]
    {
        let guessed = fonts::guess_from_postscript(ps);
        assert_eq!((guessed.family.as_str(), guessed.weight, guessed.italic), (family, weight, italic));
    }
}

#[test]
fn hyphenated_postscript_style_suffix_keeps_weight_and_slant() {
    for (ps, family, weight, italic) in [
        ("MyriadPro-Bold-It", "Myriad Pro", 700, true),
        ("FOT-NewRodinPro-Bold-It", "FOT-New Rodin Pro", 700, true),
        ("Vendor-Bold-Regular", "Vendor-Bold", 400, false),
    ] {
        let guessed = fonts::guess_from_postscript(ps);
        assert_eq!((guessed.family.as_str(), guessed.weight, guessed.italic), (family, weight, italic));
    }
}

#[test]
fn postscript_names() {
    let g = fonts::guess_from_postscript("MyriadPro-BoldIt");
    assert_eq!((g.family.as_str(), g.weight, g.italic), ("Myriad Pro", 700, true));
    let g = fonts::guess_from_postscript("TimesNewRomanPSMT");
    assert_eq!((g.family.as_str(), g.weight, g.italic), ("Times New Roman", 400, false));
    let g = fonts::guess_from_postscript("Arial-BoldMT");
    assert_eq!((g.family.as_str(), g.weight), ("Arial", 700));
    let mut db = fonts::FontDb::new();
    let r = db.resolve_postscript("Inter-SemiBold");
    assert_eq!((r.family.as_str(), r.weight, r.exact), ("Inter", 600, true));
    // Unknown fonts fall back gracefully in layout.
    let mut e = TextEngine::new();
    let t = styled("x", CharStyle { font_family: "Nonexistent Sans".into(), postscript_name: Some("Nope-Bold".into()), ..Default::default() });
    assert!(e.layout(&t, 72.0).glyphs[0].id != 0);
}

#[test]
fn depth_is_respected() {
    let mut e = TextEngine::new();
    let (_, r) = e.render(&TextLayer { transform: Affine::translate(2.0, 20.0), ..point("a", 20.0) }, 72.0, PixelFormat::RGBA16);
    assert_eq!(r.surface.format().sample, SampleType::U16);
    assert!(r.surface.format().alpha);
}

/// Visual check: `PHOTOCRAFT_TEXT_DUMP=/tmp/t.ppm cargo test -p photocraft-text dump -- --ignored`.
#[test]
#[ignore]
fn dump_sample() {
    use photocraft_doc::text::{Caps, TextAlign};
    let Some(path) = std::env::var_os("PHOTOCRAFT_TEXT_DUMP") else {
        return;
    };
    let mut e = if std::env::var_os("PHOTOCRAFT_TEXT_SYSTEM").is_some() { TextEngine::with_system_fonts() } else { TextEngine::new() };
    let s = CharStyle { size_pt: 28.0, ..Default::default() };
    let text =
        "Photocraft Type\nBold faux, italic faux, underline\nשלום عربي mixed ✓\nJustified paragraph text wraps inside the box nicely and evenly across lines.";
    let runs = vec![
        TextRun { len: 16, style: CharStyle { size_pt: 40.0, color: Color::rgb(0.1, 0.3, 0.9), caps: Caps::Normal, ..s.clone() } },
        TextRun { len: 5, style: CharStyle { faux_bold: true, ..s.clone() } },
        TextRun { len: 13, style: CharStyle { faux_italic: true, color: Color::rgb(0.8, 0.1, 0.1), ..s.clone() } },
        TextRun { len: 11, style: CharStyle { underline: true, strikethrough: false, ..s.clone() } },
        TextRun { len: 1000, style: CharStyle { size_pt: 20.0, tracking: 20.0, ..s.clone() } },
    ];
    let t = TextLayer {
        text: text.into(),
        runs,
        paragraphs: vec![
            ParagraphRun { len: 45, style: ParagraphStyle { align: TextAlign::Left, ..Default::default() } },
            ParagraphRun { len: 1000, style: ParagraphStyle { align: TextAlign::JustifyLeft, space_before_pt: 6.0, ..Default::default() } },
        ],
        shape: TextShape::Box { x: 0.0, y: 0.0, width: 560.0, height: 400.0 },
        transform: Affine::translate(20.0, 20.0),
        ..Default::default()
    };
    let (_, r) = e.render(&t, 72.0, PixelFormat::RGBA8);
    let (w, h) = (600u32, 360u32);
    let mut out = format!("P6 {w} {h} 255\n").into_bytes();
    for y in 0..h as i32 {
        for x in 0..w as i32 {
            let p = r.surface.pixel(x, y);
            let a = p[3];
            for c in &p[..3] {
                out.push(((c * a + (1.0 - a)) * 255.0).round() as u8);
            }
        }
    }
    std::fs::write(path, out).unwrap();
}

/// Variable-font axes reach the outlines (uses a system variable font when one is present).
#[test]
fn variable_font_axes() {
    let candidates =
        ["/System/Library/Fonts/SFNS.ttf", "/usr/share/fonts/truetype/noto/NotoSans-VariableFont_wdth,wght.ttf", "C:\\Windows\\Fonts\\bahnschrift.ttf"];
    let Some(bytes) = candidates.iter().find_map(|p| std::fs::read(p).ok()) else {
        return;
    };
    let mut e = TextEngine::new();
    let fams = e.fonts.register_font_data(bytes);
    let Some(fam) = fams.first().cloned() else {
        return;
    };
    if !e.fonts.faces(&fam).iter().any(|f| f.axes.iter().any(|a| a.0 == "wght")) {
        return;
    }
    let ink = |e: &mut TextEngine, w: f32| {
        let s = CharStyle {
            font_family: fam.clone(),
            size_pt: 40.0,
            variations: vec![photocraft_doc::text::FontVariation { axis: "wght".into(), value: w }],
            ..Default::default()
        };
        let (_, r) = e.render(&TextLayer { transform: Affine::translate(0.0, 50.0), ..styled("Weight", s) }, 72.0, PixelFormat::RGBA8);
        alpha_sum(&r.surface, r.rect)
    };
    let light = ink(&mut e, 200.0);
    let heavy = ink(&mut e, 800.0);
    assert!(heavy > light * 1.5, "{light} → {heavy}");
}

/// #8797: a style that carries the PostScript name of a variable font's named condensed light
/// instance lays out as wide as that instance's axis values, not at the default instance. Uses
/// Bahnschrift (Windows) or Ubuntu Sans (Ubuntu) when installed, and skips otherwise; the
/// synthesized-font tests in `font_names_tests` cover the instance lookup and its layout width
/// everywhere.
#[test]
fn postscript_name_of_a_variable_instance_lays_out_at_that_instance() {
    use photocraft_doc::text::FontVariation;
    let candidates = [
        ("C:\\Windows\\Fonts\\bahnschrift.ttf", "Bahnschrift-LightCondensed"),
        ("/usr/share/fonts/truetype/ubuntu/UbuntuSans[wdth,wght].ttf", "UbuntuSans-CondensedLight"),
    ];
    let Some((bytes, ps)) = candidates.iter().find_map(|(p, ps)| std::fs::read(p).ok().map(|b| (b, *ps))) else {
        return;
    };
    let mut e = TextEngine::new();
    let Some(fam) = e.fonts.register_font_data(bytes).first().cloned() else {
        return;
    };
    let width = |e: &mut TextEngine, style: CharStyle| {
        let l = e.layout(&styled("Hamburgefonstiv 0123", style), 96.0);
        l.lines[0].x1 - l.lines[0].x0
    };
    let base = CharStyle { font_family: fam.clone(), size_pt: 72.0, weight: 300, ..Default::default() };
    let axes = vec![FontVariation { axis: "wght".into(), value: 300.0 }, FontVariation { axis: "wdth".into(), value: 75.0 }];
    let family = width(&mut e, base.clone());
    let instance = width(&mut e, CharStyle { postscript_name: Some(ps.into()), ..base.clone() });
    let explicit = width(&mut e, CharStyle { variations: axes, ..base });
    assert!(explicit < family * 0.9, "the condensed light axes are narrower: {explicit} vs {family}");
    assert!((instance - explicit).abs() < 0.5, "{ps}: {instance} px, its axes: {explicit} px, default instance: {family} px");
}

#[test]
fn warp_bends_rendered_text_and_outlines() {
    use photocraft_doc::text::TextWarp;
    let mut e = TextEngine::new();
    let mut t = point("WARPED TEXT", 24.0);
    t.transform = Affine::translate(20.0, 60.0);
    let fmt = PixelFormat::RGBA8;
    let (_, flat) = e.render(&t, 72.0, fmt);
    t.warp = Some(TextWarp { style: "warpArc".into(), value: 60.0, horizontal: true, ..Default::default() });
    let (layout, arced) = e.render(&t, 72.0, fmt);
    // An arc pushes the ends down: the warped ink is taller and pixels differ.
    assert!(arced.rect.height() > flat.rect.height() + 10, "{:?} vs {:?}", arced.rect, flat.rect);
    assert!(alpha_sum(&arced.surface, arced.rect) > 0.0);
    // Outlines follow the same warp: the first glyph's outline sits lower than the middle one's.
    let warp = crate::render::layout_warp(&layout, t.warp.as_ref());
    let outs = crate::render::outlines(&layout, &t.transform, warp.as_ref());
    assert_eq!(outs.len(), layout.glyphs.iter().filter(|g| g.id != 0).count() - 1, "space has no outline");
    let low_y = |els: &Vec<crate::render::PathEl>| {
        els.iter()
            .filter_map(|e| match e {
                crate::render::PathEl::MoveTo(p) | crate::render::PathEl::LineTo(p) => Some(p[1]),
                _ => None,
            })
            .fold(f64::MIN, f64::max)
    };
    assert!(low_y(&outs[0]) > low_y(&outs[outs.len() / 2]) + 5.0);
    // Unwarped outlines stay within the flat raster's bounds.
    let flat_outs = crate::render::outlines(&layout, &t.transform, None);
    let r = flat.rect;
    for els in &flat_outs {
        for el in els {
            if let crate::render::PathEl::MoveTo(p) | crate::render::PathEl::LineTo(p) = el {
                assert!(p[0] >= f64::from(r.x0) && p[0] <= f64::from(r.x1) && p[1] >= f64::from(r.y0) && p[1] <= f64::from(r.y1));
            }
        }
    }
}

/// `Txt2` as Photoshop writes it (a bare `/key value` sequence; text objects at `/1 /1`, style
/// runs at `/0 /6 /0`, auto-kern mode at `/11`), for the layer text `text`.
fn txt2_with_modes(text: &str, modes: &[(usize, i64)]) -> Vec<u8> {
    txt2_with_styles(text, &modes.iter().map(|(len, m)| (*len, format!("/11 {m}"))).collect::<Vec<_>>())
}

/// [`txt2_with_modes`] with each style run's keys given as EngineData text (`"/11 1 /85 2"`).
fn txt2_with_styles(text: &str, styles: &[(usize, String)]) -> Vec<u8> {
    let mut v = b"\n\n/98 << /0 14 >> /0 << >> /1 << /1 [ << /0 << /0 (\xfe\xff".to_vec();
    for u in format!("{text}\r").encode_utf16() {
        let b = u.to_be_bytes();
        for x in b {
            if matches!(x, b'(' | b')' | b'\\') {
                v.push(b'\\');
            }
            v.push(x);
        }
    }
    v.extend_from_slice(b") /6 << /0 [ ");
    for (len, keys) in styles {
        v.extend_from_slice(format!("<< /0 << /0 << /0 (\u{fe}\u{ff}) /6 << /0 0 {keys} >> >> >> /1 {len} >> ").as_bytes());
    }
    v.extend_from_slice(b"] >> >> >> ] >>");
    v
}

fn with_text_index(tysh: &[u8], index: i32) -> Vec<u8> {
    let mut t = crate::psd::parse_tysh(tysh).unwrap();
    t.text.items.retain(|(k, _)| !k.is("TextIndex"));
    t.text.items.push((photocraft_psd::descriptor::Id::new("TextIndex"), photocraft_psd::descriptor::Value::Integer(index)));
    crate::psd::write_tysh(&t)
}

/// Optical (and "0") kerning only lives in `Txt2`: import applies it when the layer's
/// `TextIndex` object still holds the same text.
#[test]
fn txt2_carries_optical_kerning() {
    use photocraft_doc::text::Kerning;
    let t = styled("AVA", CharStyle::default());
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), 0);
    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    assert!(back.char_runs().iter().all(|r| r.style.kerning == Kerning::Metrics));
    // "AVA\r": two optical characters, then manual ("0") for the last and the break.
    let txt2 = crate::psd::parse_txt2(&txt2_with_modes("AVA", &[(2, 2), (2, 0)])).unwrap();
    crate::psd::apply_txt2(&mut back, &tysh, &txt2);
    let modes: Vec<(usize, Kerning)> = back.char_runs().iter().map(|r| (r.len, r.style.kerning)).collect();
    assert_eq!(modes, vec![(2, Kerning::Optical), (1, Kerning::Off)]);
    // Stale Txt2 (other text), another index or garbage: nothing changes, nothing panics.
    for (data, index) in [(txt2_with_modes("AVX", &[(4, 2)]), 0), (txt2_with_modes("AVA", &[(4, 2)]), 3), (b"<< /1 [ (x".to_vec(), 0), (Vec::new(), 0)] {
        let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), index);
        let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
        if let Some(txt2) = crate::psd::parse_txt2(&data) {
            crate::psd::apply_txt2(&mut l, &tysh, &txt2);
        }
        assert!(
            l.char_runs().iter().all(|r| r.style.kerning == Kerning::Metrics),
            "case {index}: {:?}",
            l.char_runs().iter().map(|r| r.style.kerning).collect::<Vec<_>>()
        );
    }
    // Run lengths longer than the text, zero lengths and odd modes are tolerated.
    let txt2 = crate::psd::parse_txt2(&txt2_with_modes("AVA", &[(0, 2), (100, 2), (5, 9)])).unwrap();
    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    crate::psd::apply_txt2(&mut l, &tysh, &txt2);
    assert!(l.char_runs().iter().all(|r| r.style.kerning == Kerning::Optical));
}

/// #3617: Photoshop keeps Stylistic Sets, Contextual Alternates, Swash and the other OpenType
/// settings besides (discretionary) ligatures only in `Txt2`. Import reads them, so the layout
/// our engine draws when the type is edited keeps Photoshop's glyphs instead of falling back to
/// the default ones.
#[test]
fn txt2_carries_opentype_features() {
    let feats = |l: &TextLayer| l.char_runs().iter().map(|r| r.style.features.iter().map(|f| (f.tag.clone(), f.value)).collect::<Vec<_>>()).collect::<Vec<_>>();
    let f = |tag: &str, value: u16| (tag.to_string(), value);
    // "Il->36" plus the engine's closing break: Stylistic Set 2 (mask 2), Contextual Alternates
    // and Swash on "Il"; Contextual Alternates off (Photoshop's default), Stylistic Set 1 and
    // Fractions on the rest.
    let text = "Il->36";
    let plain = styled(text, CharStyle { font_family: "Inter".into(), ..Default::default() });
    let tysh = with_text_index(&crate::psd::build_tysh(&plain, 72.0, None), 0);
    let styles = [(2, "/11 1 /18 true /19 false /20 true /25 true /85 2".to_string()), (5, "/11 1 /20 false /23 true /85 1".to_string())];
    let txt2 = crate::psd::parse_txt2(&txt2_with_styles(text, &styles)).unwrap();
    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    assert_eq!(feats(&back), vec![Vec::<(String, u16)>::new()], "EngineData alone doesn't have them");
    crate::psd::apply_txt2(&mut back, &tysh, &txt2);
    assert_eq!(feats(&back), vec![vec![f("calt", 1), f("swsh", 1), f("ss02", 1)], vec![f("calt", 0), f("frac", 1), f("ss01", 1)]]);
    assert_eq!(back.char_runs().iter().map(|r| r.len).collect::<Vec<_>>(), vec![2, 4]);
    // What editing shows (our layout) has Photoshop's glyphs: Inter's `ss02` draws another I and
    // l, `ss01` another 3 and 6, and `->` stays two glyphs without `calt` (with it, an arrow).
    let mut e = TextEngine::new();
    let ids = |e: &mut TextEngine, t: &TextLayer| e.layout(t, 72.0).glyphs.iter().map(|g| g.id).collect::<Vec<_>>();
    let with = |len: usize, tags: &[(&str, u16)]| TextRun {
        len,
        style: CharStyle {
            features: tags.iter().map(|(tag, value)| FontFeature { tag: (*tag).into(), value: *value }).collect(),
            ..back.char_runs()[0].style.clone()
        },
    };
    let mut expected = back.clone();
    expected.runs = vec![with(2, &[("ss02", 1)]), with(4, &[("calt", 0), ("ss01", 1)])];
    let shown = ids(&mut e, &back);
    assert_eq!(shown, ids(&mut e, &expected));
    let defaults = ids(&mut e, &crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap());
    assert_eq!((shown.len(), defaults.len()), (6, 5), "`->` is two glyphs, as in Photoshop, not an arrow");
    assert!(shown.first() != defaults.first() && shown.last() != defaults.last(), "{shown:?} vs {defaults:?}");
    // A feature the style already sets (from EngineData, read first) keeps its value; masks and
    // flags of the wrong type, masks beyond the 20 sets and unknown keys change nothing.
    let mut t = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    t.runs = vec![TextRun { len: text.len(), style: CharStyle { features: vec![FontFeature { tag: "ss01".into(), value: 0 }], ..Default::default() } }];
    let odd =
        [(1, "/85 1".to_string()), (1, "/85 (x) /20 (x) /25 (true)".to_string()), (1, "/85 -1".to_string()), (4, "/85 99999999999 /999 true".to_string())];
    crate::psd::apply_txt2(&mut t, &tysh, &crate::psd::parse_txt2(&txt2_with_styles(text, &odd)).unwrap());
    assert_eq!(feats(&t), vec![vec![f("ss01", 0)]]);
}

/// A `Txt2` written by [`crate::psd::build_txt2`] (what PSD export writes for the type layers)
/// restores every auto-kern mode on import (#1348: a new Optical layer used to reopen as
/// Metrics, because EngineData's `AutoKerning true` covers both).
#[test]
fn build_txt2_round_trips_kerning_modes() {
    use photocraft_doc::text::Kerning;
    let style = |kerning: Kerning, kern: f32| CharStyle { kerning, kern, ..Default::default() };
    let t = runs_of("AVAT", &[(2, style(Kerning::Optical, 0.0)), (1, style(Kerning::Metrics, 0.0)), (1, style(Kerning::Off, 0.0))]);
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), 0);
    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    assert!(
        back.char_runs().iter().all(|r| r.style.kerning != Kerning::Optical),
        "EngineData alone can't say Optical: {:?}",
        back.char_runs().iter().map(|r| r.style.kerning).collect::<Vec<_>>()
    );
    let txt2 = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], None)).unwrap();
    crate::psd::apply_txt2(&mut back, &tysh, &txt2);
    let modes: Vec<(usize, Kerning)> = back.char_runs().iter().map(|r| (r.len, r.style.kerning)).collect();
    assert_eq!(modes, vec![(2, Kerning::Optical), (1, Kerning::Metrics), (1, Kerning::Off)]);
    // A manual kern (a nonzero pair value) is the manual mode, as in the EngineData pair fields.
    let manual = runs_of("AB", &[(1, style(Kerning::Metrics, 50.0)), (1, style(Kerning::Metrics, 0.0))]);
    let tysh = with_text_index(&crate::psd::build_tysh(&manual, 72.0, None), 0);
    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    let txt2 = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &manual)], None)).unwrap();
    crate::psd::apply_txt2(&mut back, &tysh, &txt2);
    let modes: Vec<(usize, Kerning)> = back.char_runs().iter().map(|r| (r.len, r.style.kerning)).collect();
    assert_eq!(modes, vec![(1, Kerning::Off), (1, Kerning::Metrics)]);
}

/// #3514 / #10308: the document `Txt2` is needed for Optical kerning and for OpenType settings
/// EngineData can't carry (stylistic sets, swashes, …). A fresh document of ordinary Metrics text
/// must not write Photoshop's empty stub, which some readers (Photopea) reject.
#[test]
fn needs_txt2_for_optical_and_txt2_only_opentype() {
    use photocraft_doc::text::{FontFeature, Kerning};
    let style = |kerning: Kerning| CharStyle { kerning, ..Default::default() };
    let metrics = runs_of("AV", &[(2, style(Kerning::Metrics))]);
    assert!(!crate::psd::needs_txt2(&[(0, &metrics)]));
    let off = runs_of("AV", &[(2, style(Kerning::Off))]);
    assert!(!crate::psd::needs_txt2(&[(0, &off)]), "Off lives in EngineData, not Txt2");
    let optical = runs_of("AV", &[(1, style(Kerning::Optical)), (1, CharStyle::default())]);
    assert!(crate::psd::needs_txt2(&[(0, &optical)]));
    assert!(!crate::psd::needs_txt2(&[]));
    let with_ss = |tag: &str, value: u16| {
        let mut s = style(Kerning::Metrics);
        s.features = vec![FontFeature { tag: tag.into(), value }];
        runs_of("AV", &[(2, s)])
    };
    assert!(crate::psd::needs_txt2(&[(0, &with_ss("ss01", 1))]), "stylistic set 1 lives only in Txt2");
    assert!(crate::psd::needs_txt2(&[(0, &with_ss("ss05", 1))]), "stylistic set 5 lives only in Txt2");
    assert!(!crate::psd::needs_txt2(&[(0, &with_ss("ss01", 0))]), "an off set is the default");
    assert!(crate::psd::needs_txt2(&[(0, &with_ss("swsh", 1))]), "swash lives only in Txt2");
    assert!(crate::psd::needs_txt2(&[(0, &with_ss("calt", 0))]), "calt off is Txt2-only");
    assert!(!crate::psd::needs_txt2(&[(0, &with_ss("calt", 1))]), "calt on is the default");
}

/// #10308: the fresh objects, minimal style runs, seeded font list and frame list are only for a
/// PhotoCraft-native block. A file's own block — here the older Photoshop's, with an empty
/// numbered `/0` or none at all — gets no `/0` key, frame list or font list it didn't have, and
/// a layer without a template object gets the stub it always got.
#[test]
fn photoshop_blocks_get_no_native_txt2_scaffolding() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::FontFeature;
    let style = CharStyle { font_family: "Inter".into(), features: vec![FontFeature { tag: "ss01".into(), value: 1 }], ..Default::default() };
    let t = styled("Hi", style);
    let with_doc = photoshop_era_txt2(&["Line 1"]);
    let without_doc = crate::engine_data::write_bare(&[
        ("98".into(), E::Dict(vec![("0".into(), E::Int(14))])),
        ("DocumentObjects".into(), photoshop_era_objects(&["Line 1"])),
    ]);
    for (label, prev, doc) in [("empty /0", with_doc, Some(E::dict())), ("no /0", without_doc, None)] {
        let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
        assert_eq!(out.get("0").cloned(), doc, "{label}: the file's /0 is left as it was");
        let object = out.path(&["1", "1"]).and_then(E::as_array).and_then(|a| a.first()).expect("the numbered object");
        assert!(object.get("1").is_none(), "{label}: no fresh view naming a frame the file has no list for");
        assert!(object.path(&["0", "5"]).is_none(), "{label}: no fresh paragraph runs");
    }
}

/// #10308: a fresh native object has one paragraph run per paragraph, each its UTF-16 length.
#[test]
fn fresh_native_txt2_object_has_a_paragraph_run_per_paragraph() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::FontFeature;
    let style = CharStyle { features: vec![FontFeature { tag: "ss02".into(), value: 1 }], ..Default::default() };
    let t = styled("Hi\nBy\u{e9}e", style);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], None)).unwrap();
    let object = out.path(&["1", "1"]).and_then(E::as_array).and_then(|a| a.first()).expect("the object");
    assert_eq!(object.path(&["0", "0"]).and_then(E::as_str), Some("Hi\rBy\u{e9}e\r"));
    let lens: Vec<i64> =
        object.path(&["0", "5", "0"]).and_then(E::as_array).expect("paragraph runs").iter().filter_map(|r| r.get("1").and_then(E::as_i64)).collect();
    assert_eq!(lens, vec![3, 5]);
    assert_eq!(out.path(&["0", "8", "0"]).and_then(E::as_array).map(<[E]>::len), Some(1), "a native block names one frame");
}

/// A kept `Txt2` object — same text, so its extras are still true — keeps everything the file
/// held beyond the regenerated keys (Photoshop stores glyph pen positions under `/21 /1`), and a
/// changed text drops those extras with the stale runs. The block's own extras always survive.
#[test]
fn txt2_keeps_a_kept_objects_extras_and_drops_them_with_its_text() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let style = |kerning: Kerning, kern: f32| CharStyle { kerning, kern, ..Default::default() };
    // The file's block: object 0 with `/21 /1` pen positions, a model extra, and a block extra.
    let obj = E::Dict(vec![
        (
            "0".into(),
            E::Dict(vec![("0".into(), E::String("AB\r".into())), ("6".into(), E::Dict(vec![("0".into(), E::Array(vec![]))])), ("keep".into(), E::Int(7))]),
        ),
        ("21".into(), E::Dict(vec![("1".into(), E::Array(vec![E::Real(1.5), E::Real(2.5)]))])),
    ]);
    let prev = crate::engine_data::write_bare(&[
        ("98".into(), E::Dict(vec![("0".into(), E::Int(14))])),
        ("0".into(), E::dict()),
        ("1".into(), E::Dict(vec![("1".into(), E::Array(vec![obj]))])),
        ("extra".into(), E::Int(3)),
    ]);
    // Same text: the extras survive, the style runs are ours.
    let t = runs_of("AB", &[(1, style(Kerning::Optical, 0.0)), (1, style(Kerning::Metrics, 0.0))]);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
    assert_eq!(out.get("extra").and_then(E::as_i64), Some(3), "block extras survive");
    let object = out.path(&["1", "1"]).and_then(E::as_array).unwrap()[0].clone();
    assert_eq!(object.path(&["21", "1"]).and_then(E::as_array).map(|items| items.len()), Some(2), "pen positions survive an unchanged text");
    assert_eq!(object.path(&["0", "keep"]).and_then(E::as_i64), Some(7), "model extras survive");
    assert_eq!(object.path(&["0", "6", "0"]).and_then(E::as_array).map(|items| items.len()), Some(2), "the style runs are regenerated");
    // Changed text: the extras go stale with the old runs and are dropped.
    let t = runs_of("XY", &[(1, style(Kerning::Optical, 0.0)), (1, style(Kerning::Metrics, 0.0))]);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
    assert_eq!(out.get("extra").and_then(E::as_i64), Some(3), "block extras survive a text change too");
    let object = out.path(&["1", "1"]).and_then(E::as_array).unwrap()[0].clone();
    assert!(object.get("21").is_none(), "pen positions of another text are dropped: {:?}", object.get("21"));
    assert!(object.path(&["0", "keep"]).is_none(), "model extras of another text are dropped");
}

/// The `DocumentObjects` value older Photoshop writes beside the numbered objects
/// (`/DocumentObjects /TextObjects`, named keys, run lengths under `/Length` in UTF-16 units,
/// #6971): one entry per layer, its `\r`-terminated text in `Model /Text`, one paragraph run per
/// paragraph, one style and kern run covering the whole text.
fn photoshop_era_objects(texts: &[&str]) -> crate::engine_data::Value {
    use crate::engine_data::Value as E;
    let run = |len: i64| E::Dict(vec![("RunData".into(), E::Dict(vec![("0".into(), E::String(String::new()))])), ("Length".into(), E::Int(len))]);
    let entries = texts
        .iter()
        .map(|t| {
            let text = format!("{t}\r");
            let paragraphs: Vec<i64> = text.split_inclusive('\r').map(|p| p.encode_utf16().count() as i64).collect();
            let total = text.encode_utf16().count() as i64;
            E::Dict(vec![
                (
                    "Model".into(),
                    E::Dict(vec![
                        ("Text".into(), E::String(text)),
                        ("ParagraphRun".into(), E::Dict(vec![("RunArray".into(), E::Array(paragraphs.iter().map(|&n| run(n)).collect()))])),
                        ("StyleRun".into(), E::Dict(vec![("RunArray".into(), E::Array(vec![run(total)]))])),
                        ("KernRun".into(), E::Dict(vec![("RunArray".into(), E::Array(vec![run(total)]))])),
                    ]),
                ),
                ("View".into(), E::Dict(vec![("0".into(), E::Array(vec![E::Dict(vec![("0".into(), E::Int(0))])]))])),
            ])
        })
        .collect();
    E::Dict(vec![("TextObjects".into(), E::Array(entries))])
}

/// A whole `Txt2` block shaped like the older Photoshop's: document resources and the objects at
/// `/DocumentObjects /TextObjects`, no numbered `/1 /1` list at all.
fn photoshop_era_txt2(texts: &[&str]) -> Vec<u8> {
    use crate::engine_data::Value as E;
    crate::engine_data::write_bare(&[
        ("98".into(), E::Dict(vec![("0".into(), E::Int(14))])),
        ("0".into(), E::dict()),
        ("DocumentObjects".into(), photoshop_era_objects(texts)),
    ])
}

/// #6971: Photoshop re-renders a type layer from the objects older Photoshop keeps at
/// `/DocumentObjects /TextObjects` when the file has them, so an edit that left the old text
/// there showed the old text back on reopen. The save refits that copy the way it refits the
/// numbered ones — the new text, one paragraph run per paragraph of it, the other runs to its
/// total — and keeps the entries' view and the rest.
#[test]
fn edited_text_updates_the_photoshop_era_objects() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let prev = photoshop_era_txt2(&["Line 1\rLine 2"]);
    let before = crate::psd::parse_txt2(&prev).unwrap();
    let t = styled("Hi\nBye", CharStyle { kerning: Kerning::Optical, ..Default::default() });
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
    let entries = out.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).expect("the objects");
    assert_eq!(entries.len(), 1, "no entry is added");
    let entry = entries.first().expect("the entry");
    let model = entry.get("Model").expect("the model");
    assert_eq!(model.get("Text").and_then(E::as_str), Some("Hi\rBye\r"), "the stale text is replaced");
    let lens = |key: &str| -> Vec<i64> {
        model
            .path(&[key, "RunArray"])
            .and_then(E::as_array)
            .map(|rs| rs.iter().map(|r| r.get("Length").and_then(E::as_i64).unwrap_or(-1)).collect())
            .unwrap_or_default()
    };
    assert_eq!(lens("ParagraphRun"), vec![3, 4], "one paragraph run per paragraph of the new text");
    assert_eq!(lens("StyleRun"), vec![7], "the style runs cover the new text's UTF-16 units");
    assert_eq!(lens("KernRun"), vec![7]);
    assert_eq!(
        entry.get("View"),
        before.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).and_then(|e| e.first()).and_then(|e| e.get("View")),
        "the view is kept"
    );
    // The numbered list is written alongside, as it was before this fix.
    let slots = out.path(&["1", "1"]).and_then(E::as_array).expect("the numbered objects");
    assert_eq!(slots.len(), 1);
    assert_eq!(slots.first().and_then(|o| o.path(&["0", "0"])).and_then(E::as_str), Some("Hi\rBye\r"));
}

/// Only the entries of layers the save holds change: another layer's object — one no layer names
/// — is written back as the file has it.
#[test]
fn only_the_edited_photoshop_era_object_changes() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let prev = photoshop_era_txt2(&["One", "Two"]);
    let before = crate::psd::parse_txt2(&prev).unwrap();
    let style = |kerning: Kerning| CharStyle { kerning, ..Default::default() };
    let t0 = runs_of("One", &[(3, style(Kerning::Metrics))]);
    let t1 = runs_of("Changed", &[(7, style(Kerning::Optical))]);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t0), (1, &t1)], Some(&prev))).unwrap();
    let entries = out.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).expect("the objects");
    let was = before.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).expect("the objects before");
    assert_eq!(entries.len(), 2, "no entry is added");
    assert_eq!(entries.first(), was.first(), "the unchanged entry is written back as it was");
    assert_eq!(entries.get(1).and_then(|e| e.path(&["Model", "Text"])).and_then(E::as_str), Some("Changed\r"), "the edited entry takes the new text");
}

/// Files saved by the old code have both lists: the numbered object current, the older copy still
/// holding the text of an earlier edit. Re-saving repairs the stale copy even when the numbered
/// object's text matches the layer (nothing else about the file changes).
#[test]
fn legacy_file_with_both_object_lists_repairs_the_stale_one() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let mut prev = photoshop_txt2(&[(4, 1)]);
    prev.extend_from_slice(&crate::engine_data::write_bare(&[("DocumentObjects".into(), photoshop_era_objects(&["Old stuff"]))]));
    let before = crate::psd::parse_txt2(&prev).unwrap();
    let t = styled("AVA", CharStyle { kerning: Kerning::Metrics, ..Default::default() });
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
    let entries = out.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).expect("the objects");
    assert_eq!(entries.len(), 1);
    let model = entries.first().expect("the entry").get("Model").expect("the model");
    assert_eq!(model.get("Text").and_then(E::as_str), Some("AVA\r"), "the stale copy is repaired");
    let lens = model
        .path(&["StyleRun", "RunArray"])
        .and_then(E::as_array)
        .map(|rs| rs.iter().map(|r| r.get("Length").and_then(E::as_i64).unwrap_or(-1)).collect::<Vec<_>>());
    assert_eq!(lens, Some(vec![4]), "its runs cover the layer's text");
    let slots = out.path(&["1", "1"]).and_then(E::as_array).expect("the numbered objects");
    assert_eq!(slots.first().and_then(|o| o.path(&["0", "0"])).and_then(E::as_str), Some("AVA\r"), "the numbered object is kept as it was");
    assert_eq!(before.path(&["1", "1"]).and_then(E::as_array).and_then(|s| s.first()), slots.first(), "the numbered object changes not at all");
}

/// When both lists hold the layer's text, the block is written back byte for byte — #2374 holds
/// for the older objects too: re-encoding them would only risk Photoshop refusing the file.
#[test]
fn unchanged_block_with_both_object_lists_is_byte_identical() {
    use photocraft_doc::text::Kerning;
    let mut prev = photoshop_txt2(&[(4, 1)]);
    prev.extend_from_slice(&crate::engine_data::write_bare(&[("DocumentObjects".into(), photoshop_era_objects(&["AVA"]))]));
    let t = styled("AVA", CharStyle { kerning: Kerning::Metrics, ..Default::default() });
    assert_eq!(crate::psd::build_txt2(&[(0, &t)], Some(&prev)), prev);
}

/// An entry shaped unlike Photoshop writes it — a run without its `/Length`, a `RunArray` that
/// isn't an array, an empty one, an object with no text to replace — is left exactly as the file
/// has it: a half-refitted object (new text over old runs) is what made Photoshop quit (#6968),
/// so the save never writes one.
#[test]
fn odd_photoshop_era_entries_are_left_as_the_file_has_them() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let run = |len: i64| E::Dict(vec![("RunData".into(), E::dict()), ("Length".into(), E::Int(len))]);
    let entry = |model: Vec<(&str, E)>| {
        E::Dict(vec![("Model".into(), E::Dict(model.into_iter().map(|(k, v)| (k.to_string(), v)).collect())), ("View".into(), E::dict())])
    };
    let with_text = |text: E, style: E| {
        entry(vec![
            ("Text", text),
            ("ParagraphRun", E::Dict(vec![("RunArray".into(), E::Array(vec![run(4)]))])),
            ("StyleRun", E::Dict(vec![("RunArray".into(), style)])),
        ])
    };
    let odd = [
        with_text(E::String("Old\r".into()), E::Array(vec![E::Dict(vec![("RunData".into(), E::dict())])])),
        with_text(E::String("Old\r".into()), E::Int(3)),
        with_text(E::String("Old\r".into()), E::Array(vec![])),
        E::Int(3),
        entry(vec![("ParagraphRun", E::Dict(vec![("RunArray".into(), E::Array(vec![run(4)]))]))]),
        with_text(E::Int(9), E::Array(vec![run(4)])),
    ];
    for (i, object) in odd.iter().enumerate() {
        let prev = crate::engine_data::write_bare(&[
            ("98".into(), E::Dict(vec![("0".into(), E::Int(14))])),
            ("0".into(), E::dict()),
            ("DocumentObjects".into(), E::Dict(vec![("TextObjects".into(), E::Array(vec![object.clone()]))])),
        ]);
        let was = crate::psd::parse_txt2(&prev).unwrap();
        let t = styled("New", CharStyle { kerning: Kerning::Optical, ..Default::default() });
        let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
        let entries = out.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).expect("the objects");
        assert_eq!(
            entries.first(),
            was.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).and_then(|e| e.first()),
            "entry {i} is left as the file has it"
        );
    }
}

/// A `TextIndex` past the entries the block holds has no stale copy to fix: nothing is grown to
/// the layer's number (the slot list grows as it always did), and the entries stay the file's.
#[test]
fn a_text_index_beyond_the_photoshop_era_entries_grows_nothing() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let prev = photoshop_era_txt2(&["Only one"]);
    let was = crate::psd::parse_txt2(&prev).unwrap();
    let t = styled("Whatever", CharStyle { kerning: Kerning::Optical, ..Default::default() });
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(crate::psd::MAX_TEXT_INDEX, &t)], Some(&prev))).unwrap();
    let entries = out.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).expect("the objects");
    assert_eq!(entries.len(), 1, "no entry is grown to the layer's number");
    assert_eq!(entries.first(), was.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).and_then(|e| e.first()));
}

/// A `Txt2` shaped like Photoshop's: document resources and settings beside the text objects
/// (`/0`, `/1 /0`, `/1 /2`), style runs carrying a full style (font, size, leading) besides the
/// auto-kern mode, a Latin-1 string without a byte-order mark, reals, and a second object no
/// layer names. `modes` are the object's `(UTF-16 length, auto-kern mode)` runs for "AVA\r".
fn photoshop_txt2(modes: &[(usize, i64)]) -> Vec<u8> {
    let mut v = b"\n\n/98 << /0 14 >> /0 << /1 << /0 [ << /0 << /0 (MyriadPro-Regular) /2 0 >> >> ] >> >> /1 << /0 << /0 1 /1 .5 >> /1 [ << /0 << /0 (\xfe\xff\0A\0V\0A\0\r) /6 << /0 [ ".to_vec();
    for (len, m) in modes {
        v.extend_from_slice(format!("<< /0 << /0 << /0 (\u{fe}\u{ff}) /6 << /0 0 /1 12.0 /2 14.5 /11 {m} >> >> >> /1 {len} >> ").as_bytes());
    }
    v.extend_from_slice(
        b"] >> /7 << /0 1 >> >> /21 << /1 [ 1.25 2.5 ] >> >> << /0 << /0 (\xfe\xff\0B\0\r) >> /21 << /1 [ 3.0 ] >> >> ] /2 << /0 7 >> >> /3 << /0 .25 >>",
    );
    v
}

/// #2374: an unedited save hands Photoshop back its own `Txt2`, byte for byte. Rebuilding it
/// dropped `/1 /0` and `/1 /2`, emptied unnamed objects and cut every style run down to its
/// auto-kern mode, and Photoshop refused to open the file.
#[test]
fn unchanged_txt2_is_written_back_byte_for_byte() {
    use photocraft_doc::text::Kerning;
    let prev = photoshop_txt2(&[(2, 1), (2, 1)]);
    let tysh = with_text_index(&crate::psd::build_tysh(&styled("AVA", CharStyle::default()), 72.0, None), 0);
    let mut t = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    crate::psd::apply_txt2(&mut t, &tysh, &crate::psd::parse_txt2(&prev).unwrap());
    assert!(t.char_runs().iter().all(|r| r.style.kerning == Kerning::Metrics));
    assert_eq!(crate::psd::build_txt2(&[(0, &t)], Some(&prev)), prev);
    // An optical run reads back and writes back the same way.
    let prev = photoshop_txt2(&[(1, 2), (3, 1)]);
    crate::psd::apply_txt2(&mut t, &tysh, &crate::psd::parse_txt2(&prev).unwrap());
    assert_eq!(t.char_runs().first().map(|r| r.style.kerning), Some(Kerning::Optical));
    assert_eq!(crate::psd::build_txt2(&[(0, &t)], Some(&prev)), prev);
}

/// An edited auto-kern mode changes only `/11` (splitting the run it falls inside); the file's
/// style keys, the other `/1` keys and the objects no layer names all survive.
#[test]
fn edited_txt2_keeps_the_files_styles_and_objects() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::Kerning;
    let prev = photoshop_txt2(&[(4, 1)]);
    let style = |kerning: Kerning| CharStyle { kerning, ..Default::default() };
    let t = runs_of("AVA", &[(1, style(Kerning::Optical)), (2, style(Kerning::Metrics))]);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
    let before = crate::psd::parse_txt2(&prev).unwrap();
    for key in [&["0"][..], &["1", "0"], &["1", "2"], &["3"]] {
        assert_eq!(out.path(key), before.path(key), "/{} survives", key.join(" /"));
    }
    let objects = out.path(&["1", "1"]).and_then(E::as_array).unwrap();
    assert_eq!(objects.len(), 2, "the object no layer names is kept");
    assert_eq!(objects.get(1), before.path(&["1", "1"]).and_then(E::as_array).unwrap().get(1));
    let object = &objects[0];
    assert_eq!(object.path(&["0", "7", "0"]).and_then(E::as_i64), Some(1), "model extras survive");
    assert!(object.path(&["21", "1"]).is_some(), "pen positions survive an unchanged text");
    let runs = object.path(&["0", "6", "0"]).and_then(E::as_array).unwrap();
    let got: Vec<(i64, i64)> =
        runs.iter().map(|r| (r.get("1").and_then(E::as_i64).unwrap(), r.path(&["0", "0", "6", "11"]).and_then(E::as_i64).unwrap())).collect();
    assert_eq!(got, vec![(1, 2), (3, 1)], "the run is split where the mode changes");
    for r in runs {
        assert_eq!(r.path(&["0", "0", "6", "1"]).and_then(E::as_f64), Some(12.0), "the font size survives");
        assert_eq!(r.path(&["0", "0", "6", "2"]).and_then(E::as_f64), Some(14.5), "the leading survives");
    }
    // And it reads back with the edited modes.
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), 0);
    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    crate::psd::apply_txt2(&mut back, &tysh, &out);
    let modes: Vec<(usize, Kerning)> = back.char_runs().iter().map(|r| (r.len, r.style.kerning)).collect();
    assert_eq!(modes, vec![(1, Kerning::Optical), (2, Kerning::Metrics)]);
}

/// #6968: editing the text of a Photoshop type layer keeps its `Txt2` object — paragraph runs,
/// the view naming its frame, the model's other run arrays and its style keys — refitted to the
/// new text. It was replaced by a bare `<< /0 << /0 text /6 runs >> >>` stub, and Photoshop quit
/// while opening the file.
#[test]
fn edited_text_keeps_the_files_txt2_object() {
    use crate::engine_data::Value as E;
    let run = |extra: &str, len: usize| format!("<< /0 << /0 << /0 (\u{fe}\u{ff}) /5 << /7 1.2 >> /6 << /0 0 /1 12.0 {extra} >> >> >> /1 {len} >> ");
    // "AB\rCD\r": two paragraphs, two style runs, a kern run, a view and pen positions.
    let prev = format!(
        "\n\n/98 << /0 7 >> /0 << /8 << /0 [ << /0 << /2 << /2 [ 1.0 0.0 0.0 1.0 5.0 6.0 ] >> >> >> ] >> >> /1 << /0 << /0 1 >> /1 [ << /0 << /0 (\u{fe}\u{ff}\0A\0B\0\r\0C\0D\0\r) /5 << /0 [ {}{}] >> /6 << /0 [ {}{}] >> /7 << /0 [ << /0 << >> /1 6 >> ] >> >> /1 << /0 [ << /0 0 >> ] /2 [ << /99 /PC >> ] >> /21 << /1 [ 1.0 ] >> >> ] /2 << /0 7 >> >>",
        run("", 3),
        run("", 3),
        run("/11 1", 2),
        run("/11 1 /53 (red)", 4)
    );
    // Every character above is below U+0100: one raw byte each (the BOM `FE FF` included).
    let prev: Vec<u8> = prev.chars().map(|c| c as u32 as u8).collect();
    let before = crate::psd::parse_txt2(&prev).unwrap();
    let before_object = before.path(&["1", "1"]).and_then(E::as_array).unwrap()[0].clone();
    assert_eq!(before_object.path(&["0", "0"]).and_then(E::as_str), Some("AB\rCD\r"));
    let lens = |o: &E, key: &str| -> Vec<i64> {
        o.path(&["0", key, "0"]).and_then(E::as_array).unwrap().iter().map(|r| r.get("1").and_then(E::as_i64).unwrap()).collect()
    };
    for (text, paragraphs, styles) in
        [("Bevex\nCD", vec![6, 3], vec![9]), ("AB\nCD\nEFG", vec![3, 3, 4], vec![10]), ("X", vec![2], vec![2]), ("AB\nCZ", vec![3, 3], vec![6])]
    {
        let t = runs_of(text, &[(text.len(), CharStyle::default())]);
        let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
        for key in [&["0"][..], &["98"], &["1", "0"], &["1", "2"]] {
            assert_eq!(out.path(key), before.path(key), "{text:?}: /{} survives", key.join(" /"));
        }
        let object = &out.path(&["1", "1"]).and_then(E::as_array).unwrap()[0];
        let engine = format!("{}\r", text.replace('\n', "\r"));
        let total = engine.encode_utf16().count() as i64;
        assert_eq!(object.path(&["0", "0"]).and_then(E::as_str), Some(engine.as_str()));
        assert_eq!(object.get("1"), before_object.get("1"), "{text:?}: the view (its frame) is kept");
        assert!(object.get("21").is_none(), "{text:?}: pen positions of the old text are dropped");
        assert_eq!(lens(object, "5"), paragraphs, "{text:?}: one paragraph run per paragraph");
        // Photoshop reads the character style from these runs: they follow the layer's own runs
        // (one here), built on the file's first run.
        assert_eq!(lens(object, "6"), styles, "{text:?}: style runs cover the new text");
        assert_eq!(lens(object, "7"), vec![total], "{text:?}: other run arrays cover the new text");
        for r in object.path(&["0", "5", "0"]).and_then(E::as_array).unwrap() {
            assert_eq!(r.path(&["0", "0", "5", "7"]).and_then(E::as_f64), Some(1.2), "{text:?}: paragraph style survives");
        }
        for r in object.path(&["0", "6", "0"]).and_then(E::as_array).unwrap() {
            assert_eq!(r.path(&["0", "0", "6", "1"]).and_then(E::as_f64), Some(f64::from(CharStyle::default().size_pt)), "{text:?}: the layer's font size");
            assert_eq!(r.path(&["0", "0", "5", "7"]).and_then(E::as_f64), Some(1.2), "{text:?}: the file's run keeps its other keys");
        }
    }
}

/// #8415: a style-only edit (`type.setStyle` with no text change) reaches the file's `Txt2`.
/// Photoshop reads the character style from the object's style runs, and an object whose text
/// still matched kept the file's runs, so Photoshop reopened the layer in its old font with faux
/// bold still on. A layer whose style agrees with the runs still gets the block back byte for
/// byte (#2374); one whose font or faux bold changed is restyled like an edited object, and the
/// glyph pen positions laid out in the old style are dropped.
#[test]
fn style_only_edit_restyles_the_kept_txt2_object() {
    use crate::engine_data::Value as E;
    // Strings in the block are UTF-16 with a BOM; every character here is below U+0100.
    let utf16 = |s: &str| format!("(\u{fe}\u{ff}{})", s.chars().map(|c| format!("\0{c}")).collect::<String>());
    let font = |name: &str| format!("<< /0 << /99 /CoolTypeFont /0 << /0 {} /2 1 >> >> >> ", utf16(name));
    // One object as Photoshop writes it: paragraph runs, style runs, a view and pen positions.
    let prev = format!(
        "\n\n/98 << /0 14 >> /0 << /1 << /0 [ {}{}] >> >> /1 << /1 [ << /0 << /0 {} /5 << /0 [ << /0 << /0 << /0 (\u{fe}\u{ff}) /5 << /7 1.2 >> >> >> /1 3 >> ] >> /6 << /0 [ << /0 << /0 << /0 (\u{fe}\u{ff}) /6 << /0 0 /1 12.0 /2 true /3 false /11 1 >> >> >> /1 3 >> ] >> >> /1 << /0 [ << /0 0 >> ] >> /21 << /1 [ 1.25 2.5 ] >> >> ] >>",
        font("Arial-Black"),
        font("ArialMT"),
        utf16("AV\r"),
    );
    let prev: Vec<u8> = prev.chars().map(|c| c as u32 as u8).collect();
    let style = CharStyle { postscript_name: Some("Arial-Black".into()), size_pt: 12.0, faux_bold: true, ..Default::default() };
    let t = styled("AV", style.clone());
    assert_eq!(crate::psd::build_txt2(&[(0, &t)], Some(&prev)), prev, "an unedited style keeps the file's block");

    let font_name = |out: &E, run: &E| {
        let i = run.path(&["0", "0", "6", "0"]).and_then(E::as_i64).and_then(|i| usize::try_from(i).ok()).expect("a font index");
        out.path(&["0", "1", "0"]).and_then(E::as_array).and_then(|f| f.get(i)).and_then(|f| f.path(&["0", "0", "0"])).and_then(E::as_str).map(str::to_owned)
    };
    for (what, edited, want_font) in [
        ("faux bold off", CharStyle { faux_bold: false, ..style.clone() }, "Arial-Black"),
        (
            "font and faux bold",
            CharStyle { postscript_name: Some("AppleSDGothicNeo-Heavy".into()), faux_bold: false, ..style.clone() },
            "AppleSDGothicNeo-Heavy",
        ),
    ] {
        let t = styled("AV", edited);
        let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
        let object = &out.path(&["1", "1"]).and_then(E::as_array).unwrap()[0];
        assert_eq!(object.path(&["0", "0"]).and_then(E::as_str), Some("AV\r"), "{what}: the text is unchanged");
        let runs = object.path(&["0", "6", "0"]).and_then(E::as_array).unwrap();
        assert!(!runs.is_empty(), "{what}: the object has style runs");
        for run in runs {
            assert_eq!(run.path(&["0", "0", "6", "2"]).and_then(E::as_bool), Some(false), "{what}: faux bold is off in Txt2");
            assert_eq!(font_name(&out, run).as_deref(), Some(want_font), "{what}: Txt2 names the layer's font");
        }
        assert!(object.get("21").is_none(), "{what}: pen positions of the old style are dropped");
    }
}

/// A type layer the file's `Txt2` has no object for (one added before the save, #7698) gets an
/// object shaped like the file's own, with a view naming its own frame and a frame in `/0 /8 /0`,
/// instead of a bare stub: Photoshop and Photopea refused the file when the frames ran out.
#[test]
fn new_text_layer_gets_a_txt2_object_and_frame() {
    use crate::engine_data::Value as E;
    let run = |len: usize| format!("<< /0 << /0 << /0 (\u{fe}\u{ff}) /5 << /7 1.2 >> /6 << /0 0 /1 12.0 >> >> >> /1 {len} >> ");
    let prev = format!(
        "\n\n/98 << /0 7 >> /0 << /8 << /0 [ << /0 << /2 << /2 [ 1.0 0.0 0.0 1.0 5.0 6.0 ] >> >> >> ] >> >> /1 << /0 << /0 1 >> /1 [ << /0 << /0 (\u{fe}\u{ff}\0A\0B\0\r\0C\0D\0\r) /5 << /0 [ {}{}] >> /6 << /0 [ {}] >> >> /1 << /0 [ << /0 0 >> ] /1 << /0 [ << /0 << /1 1 >> /1 3 >> << /0 << /1 1 >> /1 3 >> ] >> /2 [ << /99 /PC /6 [ << /99 /F /10 0 >> ] >> ] >> /21 << /1 [ 1.0 ] >> >> ] /2 << /0 7 >> >>",
        run(3),
        run(3),
        run(6)
    );
    // The same block after an earlier save wrote a bare stub for "v1.0" (the file in #7698).
    let stub = "<< /0 << /0 (\u{fe}\u{ff}\0v\x001\0.\x000\0\r) /6 << /0 [ << /0 << /0 << /0 () /6 << /0 0 /11 1 >> >> >> /1 5 >> ] >> >> >> ";
    let broken = prev.replace(" >> ] /2 << /0 7 >>", &format!(" >> {stub}] /2 << /0 7 >>"));
    let broken: Vec<u8> = broken.chars().map(|c| c as u32 as u8).collect();
    let prev: Vec<u8> = prev.chars().map(|c| c as u32 as u8).collect();
    let before = crate::psd::parse_txt2(&prev).unwrap();
    let old = runs_of("AB\nCD", &[(5, CharStyle::default())]);
    let new = runs_of("v1.0", &[(4, CharStyle::default())]);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &old), (1, &new)], Some(&prev))).unwrap();
    let objects = out.path(&["1", "1"]).and_then(E::as_array).unwrap();
    assert_eq!(objects.len(), 2);
    let kept = &before.path(&["1", "1"]).and_then(E::as_array).unwrap()[0];
    assert_eq!(objects[0].get("1"), kept.get("1"), "the file's object keeps its view");
    assert_eq!(objects[0].path(&["0", "5"]), kept.path(&["0", "5"]), "the file's object keeps its paragraphs");
    let frames = out.path(&["0", "8", "0"]).and_then(E::as_array).unwrap();
    assert_eq!(frames.len(), 2, "one frame per object");
    let object = &objects[1];
    assert_eq!(object.path(&["0", "0"]).and_then(E::as_str), Some("v1.0\r"));
    assert_eq!(object.path(&["1", "0"]), Some(&E::Array(vec![E::Dict(vec![("0".into(), E::Int(1))])])), "the view names its own frame");
    assert!(object.get("21").is_none());
    assert_eq!(
        object.path(&["1", "2"]).and_then(E::as_array).and_then(|s| s[0].get("6")).and_then(E::as_array).and_then(|f| f[0].get("10")),
        Some(&E::Int(1)),
        "the frame strike names its own frame"
    );
    let lens =
        |path: &[&str]| -> Vec<i64> { object.path(path).and_then(E::as_array).unwrap().iter().map(|r| r.get("1").and_then(E::as_i64).unwrap()).collect() };
    assert_eq!(lens(&["0", "5", "0"]), vec![5]);
    assert_eq!(lens(&["0", "6", "0"]), vec![5]);
    assert_eq!(lens(&["1", "1", "0"]), vec![5], "view runs follow the new paragraphs");

    // Re-saving the file with the stub repairs it: the stub is replaced like a missing object.
    assert_eq!(crate::psd::parse_txt2(&broken).unwrap().path(&["1", "1"]).and_then(E::as_array).unwrap().len(), 2);
    let repaired = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &old), (1, &new)], Some(&broken))).unwrap();
    assert_eq!(repaired, out, "a stub from an earlier save is replaced");
    // Also when the stub's layer is edited before the re-save.
    let edited = runs_of("v2.0", &[(4, CharStyle::default())]);
    let repaired = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &old), (1, &edited)], Some(&broken))).unwrap();
    let object = &repaired.path(&["1", "1"]).and_then(E::as_array).unwrap()[1];
    assert_eq!(object.path(&["0", "0"]).and_then(E::as_str), Some("v2.0\r"));
    assert_eq!(object.path(&["1", "0"]), Some(&E::Array(vec![E::Dict(vec![("0".into(), E::Int(1))])])), "an edited stub is replaced too");

    // No object to take the shape from: the fresh object as before, with the frames still padded.
    let bare = b"\n\n/98 << /0 7 >> /0 << /8 << /0 [ << /0 1 >> ] >> >> /1 << /1 [ << >> ] >> ";
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(1, &new)], Some(bare))).unwrap();
    assert_eq!(out.path(&["1", "1"]).and_then(E::as_array).unwrap().len(), 2);
    assert_eq!(out.path(&["0", "8", "0"]).and_then(E::as_array).unwrap().len(), 2);

    // An oversized object is never the template (it would be copied once per new layer).
    let filler = "0 ".repeat(5000);
    let big = prev.iter().map(|&b| b as char).collect::<String>().replace("/2 [ << /99 /PC", &format!("/9 [ {filler}] /2 [ << /99 /PC"));
    let big: Vec<u8> = big.chars().map(|c| c as u32 as u8).collect();
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &old), (1, &new)], Some(&big))).unwrap();
    let object = &out.path(&["1", "1"]).and_then(E::as_array).unwrap()[1];
    assert!(object.get("1").is_none(), "no copy of an oversized template");
    assert_eq!(out.path(&["0", "8", "0"]).and_then(E::as_array).unwrap().len(), 2);
}

/// The frame padding is bounded like the slots a layer can name: a crafted block of many empty
/// objects and no frames must not make the save write a frame for each of them.
#[test]
fn txt2_frame_padding_is_bounded() {
    use crate::engine_data::Value as E;
    let objects = "<< >> ".repeat(70_000);
    let prev = format!("\n\n/98 << /0 7 >> /0 << /8 << /0 [ ] >> >> /1 << /1 [ {objects}] >> ");
    let t = runs_of("AV", &[(2, CharStyle::default())]);
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(prev.as_bytes()))).unwrap();
    let frames = out.path(&["0", "8", "0"]).and_then(E::as_array).unwrap().len();
    assert_eq!(frames, crate::psd::MAX_TEXT_INDEX as usize + 1);
}

/// The file's style runs are only reused when they cover the text: runs of another length (or
/// hostile lengths) fall back to generated runs, without panicking.
#[test]
fn txt2_runs_that_dont_cover_the_text_are_regenerated() {
    use crate::engine_data::Value as E;
    let t = runs_of("AVA", &[(3, CharStyle::default())]);
    for modes in [&[(3, 1)][..], &[(9, 1)], &[(i64::MAX as usize, 1), (2, 1)], &[]] {
        let prev = photoshop_txt2(modes);
        let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap();
        let runs = out.path(&["1", "1"]).and_then(E::as_array).unwrap()[0].path(&["0", "6", "0"]).and_then(E::as_array).unwrap();
        let total: i64 = runs.iter().filter_map(|r| r.get("1").and_then(E::as_i64)).sum();
        assert_eq!(total, 4, "{modes:?}");
        assert!(out.path(&["1", "2"]).is_some());
    }
}

/// A file-controlled `TextIndex` must not size the save: out-of-range numbers are ignored (the
/// slot array is sized by real text objects, never by a file's numbers) and reading one back is
/// a no-op, so a hostile file degrades instead of allocating gigabytes on export.
#[test]
fn hostile_text_index_is_ignored_not_sized() {
    use crate::engine_data::Value as E;
    let t = runs_of("AB", &[(2, CharStyle::default())]);
    let tysh = crate::psd::build_tysh(&t, 72.0, None);
    assert_eq!(crate::psd::text_index(&crate::psd::set_text_index(&tysh, 0).unwrap()), Some(0));
    assert_eq!(crate::psd::text_index(&crate::psd::set_text_index(&tysh, crate::psd::MAX_TEXT_INDEX).unwrap()), Some(crate::psd::MAX_TEXT_INDEX));
    for hostile in [crate::psd::MAX_TEXT_INDEX + 1, i32::MAX] {
        assert_eq!(crate::psd::text_index(&crate::psd::set_text_index(&tysh, hostile).unwrap()), None, "{hostile}");
        let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(hostile, &t)], None)).unwrap();
        let slots = out.path(&["1", "1"]).and_then(E::as_array).unwrap();
        assert!(slots.is_empty(), "{hostile} sized {} slots", slots.len());
    }
    // The bound is real but generous: the last honoured number lands at its slot.
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(crate::psd::MAX_TEXT_INDEX, &t)], None)).unwrap();
    let slots = out.path(&["1", "1"]).and_then(E::as_array).unwrap();
    assert_eq!(slots.len(), crate::psd::MAX_TEXT_INDEX as usize + 1);
}

/// Photopea needs an enabled fill, not just FillColor, to paint text after an edit. Inspect the
/// serialized TySh rather than our renderer, which does not consume the PSD fill flag.
#[test]
fn psd_text_fill_is_enabled_in_runs_and_new_default_styles() {
    let mut t = point("AB", 100.0);
    t.runs = vec![
        TextRun { len: 1, style: CharStyle { color: Color::rgb(0.2, 0.4, 0.6), ..Default::default() } },
        TextRun { len: 1, style: CharStyle { faux_bold: true, size_pt: 100.0, ..Default::default() } },
    ];
    for shape in [TextShape::Point, TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 200.0 }] {
        t.shape = shape;
        let tysh = crate::psd::parse_tysh(&crate::psd::build_tysh(&t, 72.0, None)).unwrap();
        let data = crate::psd::engine_data(&tysh.text).unwrap();
        let runs = data.path(&["EngineDict", "StyleRun", "RunArray"]).unwrap().as_array().unwrap();
        assert_eq!(runs.len(), 2);
        for run in runs {
            assert_eq!(run.path(&["StyleSheet", "StyleSheetData", "FillFlag"]).and_then(crate::engine_data::Value::as_bool), Some(true));
        }
        for key in ["ResourceDict", "DocumentResources"] {
            let sheets = data.path(&[key, "StyleSheetSet"]).unwrap().as_array().unwrap();
            assert_eq!(sheets[0].path(&["StyleSheetData", "FillFlag"]).and_then(crate::engine_data::Value::as_bool), Some(true));
        }
        let back = crate::psd::text_layer_from_tysh(&crate::psd::write_tysh(&tysh), 72.0).unwrap();
        assert_eq!(back.text, t.text);
        assert_eq!(back.runs.len(), t.runs.len());
        for (actual, expected) in back.runs.iter().zip(&t.runs) {
            assert_eq!(actual.style.color, expected.style.color);
            assert_eq!(actual.style.size_pt, expected.style.size_pt);
            assert_eq!(actual.style.faux_bold, expected.style.faux_bold);
        }
    }
}

#[test]
fn psd_text_fill_is_enabled_after_editing_a_legacy_export() {
    use crate::engine_data::Value as E;
    // A legacy PhotoCraft export has a normal style and character runs without FillFlag.
    let mut t = point("Before", 40.0);
    let mut legacy = crate::psd::parse_tysh(&crate::psd::build_tysh(&t, 72.0, None)).unwrap();
    fn remove_fill_flags(value: &mut E) {
        match value {
            E::Dict(items) => {
                items.retain(|(key, _)| key != "FillFlag");
                for (_, value) in items {
                    remove_fill_flags(value);
                }
            }
            E::Array(items) => items.iter_mut().for_each(remove_fill_flags),
            _ => {}
        }
    }
    let mut data = crate::psd::engine_data(&legacy.text).unwrap();
    remove_fill_flags(&mut data);
    for (key, value) in &mut legacy.text.items {
        if key.as_bytes() == b"EngineData" {
            *value = photocraft_psd::descriptor::Value::RawData(crate::engine_data::write(&data));
        }
    }
    t.psd_raw = Some(crate::psd::write_tysh(&legacy).into());
    t.text = "After".into();
    let tysh = crate::psd::parse_tysh(&crate::psd::build_tysh(&t, 72.0, None)).unwrap();
    let data = crate::psd::engine_data(&tysh.text).unwrap();
    let runs = data.path(&["EngineDict", "StyleRun", "RunArray"]).unwrap().as_array().unwrap();
    assert!(!runs.is_empty());
    for run in runs {
        assert_eq!(run.path(&["StyleSheet", "StyleSheetData", "FillFlag"]).and_then(E::as_bool), Some(true));
    }
}

/// EngineData pair fields: manual kerning and "no automatic kerning" round-trip exactly, in
/// Photoshop's form (see `psd::pair_runs`).
#[test]
fn psd_round_trips_manual_kerning() {
    use photocraft_doc::text::Kerning::{Metrics as M, Off as O};
    let s = CharStyle::default();
    let cases: Vec<Vec<(usize, photocraft_doc::text::Kerning, f32)>> = vec![
        vec![(1, O, 100.0), (1, O, -50.0), (2, M, 0.0)],
        vec![(1, M, 0.0), (1, O, 0.0), (2, M, 0.0)],
        vec![(4, O, 0.0)],
        vec![(2, M, 0.0), (1, O, 25.0), (1, M, 0.0)],
        vec![(3, M, 0.0), (1, O, 300.0)],
    ];
    for runs in cases {
        let t = runs_of("AVAT", &runs.iter().map(|&(len, kerning, kern)| (len, CharStyle { kerning, kern, ..s.clone() })).collect::<Vec<_>>());
        let back = crate::psd::text_layer_from_tysh(&crate::psd::build_tysh(&t, 72.0, None), 72.0).unwrap();
        let per = |t: &TextLayer| t.char_runs().iter().flat_map(|r| std::iter::repeat_n((r.style.kerning, r.style.kern), r.len)).collect::<Vec<_>>();
        let mut want = per(&t);
        // The last character's mode has no EngineData slot (it reads back as Metrics unless
        // it has a manual kern).
        if let Some(last) = want.last_mut()
            && last.1 == 0.0
        {
            last.0 = M;
        }
        assert_eq!(per(&back), want, "{runs:?}");
    }
}

#[test]
fn psd_round_trips_antialias_opentype_and_warp() {
    use photocraft_doc::text::{AntiAlias, TextWarp};
    let style = CharStyle {
        font_family: "Inter".into(),
        size_pt: 20.0,
        features: vec![FontFeature { tag: "swsh".into(), value: 1 }, FontFeature { tag: "frac".into(), value: 1 }],
        discretionary_ligatures: true,
        ..Default::default()
    };
    for aa in [AntiAlias::Windows, AntiAlias::WindowsLcd, AntiAlias::Crisp, AntiAlias::None] {
        let mut t = styled("1/2 Swash", style.clone());
        t.antialias = aa;
        t.warp = Some(TextWarp { style: "warpFlag".into(), value: -35.0, horizontal_distortion: 10.0, vertical_distortion: 0.0, horizontal: false });
        let bytes = crate::psd::build_tysh(&t, 72.0, None);
        let back = crate::psd::text_layer_from_tysh(&bytes, 72.0).unwrap();
        assert_eq!(back.antialias, aa);
        assert_eq!(back.warp, t.warp);
        let st = &back.char_runs()[0].style;
        assert!(st.discretionary_ligatures);
        let mut tags: Vec<&str> = st.features.iter().map(|f| f.tag.as_str()).collect();
        tags.sort_unstable();
        assert_eq!(tags, ["frac", "swsh"]);
    }
}

/// EngineData only maps Photoshop's `OldStyle` bool to `onum`. Other Numerals tags (`lnum` /
/// `pnum` / `tnum`) stay in `.pcraft` until a Photoshop-authored PSD oracle exists — we do not
/// invent EngineData keys or copy figure-style tables from GPL editors (AGENTS.md clean-room).
#[test]
fn psd_engine_data_keeps_only_oldstyle_among_numeral_tags() {
    let style = CharStyle {
        font_family: "Inter".into(),
        size_pt: 20.0,
        features: ["lnum", "onum", "pnum", "tnum"].iter().map(|t| FontFeature { tag: (*t).into(), value: 1 }).collect(),
        ..Default::default()
    };
    let t = styled("0123456789", style);
    let bytes = crate::psd::build_tysh(&t, 72.0, None);
    let back = crate::psd::text_layer_from_tysh(&bytes, 72.0).expect("tysh");
    let runs = back.char_runs();
    let mut got: Vec<&str> = runs[0].style.features.iter().map(|f| f.tag.as_str()).collect();
    got.sort_unstable();
    assert_eq!(got, ["onum"]);
}

/// A legacy-signature `TySh` (#1469): zero PointBase, `bounds` (the layout box) and `boundingBox`
/// (the ink box, as Photoshop writes it) both around `anchor` in a remote local space, and a
/// `transform` that cancels the remote origin.
fn legacy_tysh(source: &TextLayer, transform: Affine, anchor: [f64; 2], engine: &mut TextEngine) -> Vec<u8> {
    use photocraft_psd::descriptor::{Descriptor, Id, Value as D};
    let layout = engine.layout(source, 72.0);
    let logical = layout.bounds().unwrap().map(f64::from);
    let ink = crate::render::ink_bounds(&layout).unwrap();
    let rect = |class, r: [f64; 4]| {
        D::Descriptor(
            Descriptor::new(class)
                .with("Left", D::UnitFloat { unit: *b"#Pnt", value: anchor[0] + r[0] })
                .with("Top ", D::UnitFloat { unit: *b"#Pnt", value: anchor[1] + r[1] })
                .with("Rght", D::UnitFloat { unit: *b"#Pnt", value: anchor[0] + r[2] })
                .with("Btom", D::UnitFloat { unit: *b"#Pnt", value: anchor[1] + r[3] }),
        )
    };
    let mut tysh = crate::psd::parse_tysh(&crate::psd::build_tysh(source, 72.0, None)).unwrap();
    tysh.transform = transform;
    tysh.text.items.retain(|(key, _)| !key.is("bounds") && !key.is("boundingBox"));
    tysh.text.items.push((Id::new("bounds"), rect("bounds", logical)));
    tysh.text.items.push((Id::new("boundingBox"), rect("boundingBox", ink)));
    crate::psd::write_tysh(&tysh)
}

fn assert_transform_near(got: Affine, want: Affine, tolerance: f64, what: &str) {
    assert!(got.m.iter().zip(want.m).all(|(g, w)| (g - w).abs() < tolerance), "{what}: {:?} vs {:?}", got.m, want.m);
}

/// #1469: Some older PSD writers combine a zero PointBase with an enormous local ink origin.
/// The layout's own ink box is lined up with the saved ink box, so point alignment anchors stay
/// fixed for left, centered and right text through import and a TySh round trip.
#[test]
fn legacy_tysh_point_origin_imports_and_round_trips_on_canvas() {
    use photocraft_psd::descriptor::Value as D;

    let original = Affine { m: [4.1667, 0.0, 0.0, 4.1667, -32375.0, -32887.5] };
    // The file's layout origin (the anchor on the first baseline) in its local space.
    let anchor = [8050.0, 8160.0];
    let expected = original.mul(&Affine::translate(anchor[0], anchor[1]));
    for align in [TextAlign::Left, TextAlign::Center, TextAlign::Right] {
        let mut source = styled("Name", CharStyle { font_family: "Inter".into(), size_pt: 120.0, ..Default::default() });
        source.paragraphs = vec![ParagraphRun { len: source.text.len(), style: ParagraphStyle { align, ..Default::default() } }];
        let mut engine = TextEngine::new();
        let data = legacy_tysh(&source, original, anchor, &mut engine);

        let mut imported = crate::psd::text_layer_from_tysh(&data, 72.0).unwrap();
        imported.psd_raw = Some(std::sync::Arc::new(data.clone()));
        crate::psd::refine_legacy_point_origin(&mut imported, 72.0, &mut engine, None);
        assert_eq!(imported.paragraph_runs()[0].style.align, align);
        assert_transform_near(imported.transform, expected, 1e-6, &format!("{align:?}: anchor"));

        let (_, rendered) = engine.render(&imported, 72.0, PixelFormat::RGBA8);
        let placed = rendered.surface.content_bounds();
        assert!(!placed.is_empty(), "{align:?}: no rendered pixels");
        let mut want = source.clone();
        want.transform = expected;
        let (_, expected_pixels) = engine.render(&want, 72.0, PixelFormat::RGBA8);
        assert_eq!(placed, expected_pixels.surface.content_bounds(), "{align:?}: raster placement");

        let native = engine.layout(&imported, 72.0).bounds();
        let round_trip = crate::psd::text_layer_from_tysh(&crate::psd::build_tysh(&imported, 72.0, native), 72.0).unwrap();
        assert_transform_near(round_trip.transform, expected, 0.01, &format!("{align:?}: round trip"));

        // A valid frame may equal the old ink-corner estimate. It must still win over refinement.
        let t = crate::psd::parse_tysh(&data).unwrap();
        let Some(D::Descriptor(ink_box)) = t.text.get("boundingBox") else { panic!("boundingBox") };
        let corner = |k| match ink_box.get(k) {
            Some(D::UnitFloat { value, .. }) => *value,
            _ => panic!("{k}"),
        };
        let framed = with_text_index(&data, 0);
        let txt2 = crate::psd::parse_txt2(&txt2_with_frame("Name", Some([corner("Left"), corner("Top ")]), [1.0, 0.0, 0.0, 1.0, 0.0, 0.0])).unwrap();
        let mut with_frame = crate::psd::text_layer_from_tysh(&framed, 72.0).unwrap();
        with_frame.psd_raw = Some(std::sync::Arc::new(framed.clone()));
        crate::psd::apply_txt2_frame(&mut with_frame, &framed, &txt2);
        let authoritative = with_frame.transform;
        crate::psd::refine_legacy_point_origin(&mut with_frame, 72.0, &mut engine, Some(&txt2));
        assert_eq!(with_frame.transform, authoritative, "{align:?}: exact frame wins");
    }
}

/// #6094 review: `boundingBox` is the tight ink box (a Photoshop-saved Arial 120 pt "..." has
/// `bounds` top -102.98 but `boundingBox` top -11). Text whose ink starts well below the ascent
/// line keeps its baseline: lining the layout box up with the ink box put "..." and "_" about
/// 116 pt too low.
#[test]
fn legacy_origin_lines_up_ink_with_the_ink_bounding_box() {
    let original = Affine { m: [1.0, 0.0, 0.0, 1.0, -7900.0, -7550.0] };
    for text in ["Name", "...", "_"] {
        let source = styled(text, CharStyle { font_family: "Inter".into(), size_pt: 120.0, ..Default::default() });
        let mut engine = TextEngine::new();
        let data = legacy_tysh(&source, original, [8000.0, 8000.0], &mut engine);
        let mut imported = crate::psd::text_layer_from_tysh(&data, 72.0).unwrap();
        imported.psd_raw = Some(std::sync::Arc::new(data));
        crate::psd::refine_legacy_point_origin(&mut imported, 72.0, &mut engine, None);
        let baseline = imported.transform.apply(photocraft_geom::Point::new(0.0, 0.0));
        assert!((baseline.x - 100.0).abs() < 1e-6 && (baseline.y - 450.0).abs() < 1e-6, "{text:?}: {baseline:?}");
    }
}

#[test]
fn legacy_origin_uses_the_rendering_engines_registered_face() {
    let mut engine = TextEngine::new();
    let mut style = CharStyle { font_family: "JetBrains Mono".into(), font_style: "Regular".into(), size_pt: 100.0, ..Default::default() };
    // This exact-face alias exists only in this engine, like a user-registered font.
    engine.fonts.select_named_face(&mut style);
    assert!(style.font_family.starts_with(".PhotoCraft-face-"));
    let source = with_para(styled("Name", style), ParagraphStyle { align: TextAlign::Right, ..Default::default() });
    let raw = legacy_tysh(&source, Affine::translate(-8000.0, -8000.0), [8100.0, 8200.0], &mut engine);
    let mut imported = crate::psd::text_layer_from_tysh(&raw, 72.0).unwrap();
    // Import preparation has resolved the face before refining placement.
    imported.runs = source.runs.clone();
    imported.sync_summary();
    imported.psd_raw = Some(std::sync::Arc::new(raw));
    crate::psd::refine_legacy_point_origin(&mut imported, 72.0, &mut engine, None);
    let placed = imported.transform.apply(photocraft_geom::Point::new(0.0, 0.0));
    assert!((placed.x - 100.0).abs() < 1e-6 && (placed.y - 200.0).abs() < 1e-6, "{placed:?}");
}

/// Regression: a PSD whose text engine data has no `EngineDict` (or isn't a dictionary)
/// panicked with `expect("EngineDict")` when the layer was written back (PSD export).
#[test]
fn engine_data_template_without_engine_dict() {
    use crate::engine_data::{self as ed, Value as E};
    let t = styled("Hi", CharStyle::default());
    let no_engine_dict = ed::parse(b"<< /ResourceDict << >> >>").unwrap();
    for template in [no_engine_dict, E::Dict(vec![]), E::Int(3)] {
        let e = crate::psd::build_engine_data(&t, Some(template), 72.0);
        let text = e.path(&["EngineDict", "Editor", "Text"]);
        assert!(matches!(text, Some(E::String(s)) if s == "Hi\r"), "{text:?}");
    }
}

/// #123: the caret geometry (clusters, lines) sits on the rendered glyphs, so a click on a glyph
/// lands next to it: its left part before it, its right part after it. Plain text, tracking,
/// horizontal scale, mixed sizes, and centred, wrapped paragraph text.
#[test]
fn clusters_sit_on_rendered_glyphs() {
    let mut e = TextEngine::new();
    let big = CharStyle { size_pt: 40.0, ..Default::default() };
    let small = CharStyle { size_pt: 18.0, ..Default::default() };
    let mixed =
        TextLayer { text: "HOHOHO".into(), runs: vec![TextRun { len: 3, style: big.clone() }, TextRun { len: 3, style: small.clone() }], ..Default::default() };
    let boxed = with_para(
        TextLayer { shape: TextShape::Box { x: 0.0, y: 0.0, width: 150.0, height: 200.0 }, ..styled("HOH HOH HOH HOH", small.clone()) },
        ParagraphStyle { align: TextAlign::Center, ..Default::default() },
    );
    let cases = [
        ("plain", styled("HOHOH", big.clone())),
        ("tracking", styled("HOHOH", CharStyle { tracking: 300.0, ..big.clone() })),
        ("hscale", styled("HOHOH", CharStyle { horizontal_scale: 1.6, ..big.clone() })),
        ("kerned", styled("HOHOH", CharStyle { kern: 250.0, kerning: photocraft_doc::text::Kerning::Optical, ..big.clone() })),
        ("mixed", mixed),
        ("box", boxed),
    ];
    for (name, t) in cases {
        let t = TextLayer { transform: Affine::translate(7.0, 60.0), ..t };
        let (l, r) = e.render(&t, 72.0, PixelFormat::RGBA8);
        assert!(l.lines.len() >= if name == "box" { 2 } else { 1 }, "{name}");
        for c in l.clusters.iter().filter(|c| !t.text[c.range.clone()].trim().is_empty()) {
            let ln = &l.lines[c.line];
            // Ink under the cluster's middle, between the line's ascent and descent.
            let col = photocraft_geom::Rect::new(
                (c.x + c.advance * 0.3 + 7.0).floor() as i32,
                (ln.baseline - ln.ascent + 60.0).floor() as i32,
                (c.x + c.advance * 0.55 + 7.0).ceil() as i32,
                (ln.baseline + ln.descent + 60.0).ceil() as i32,
            );
            assert!(alpha_sum(&r.surface, col) > 1.0, "{name}: no ink under cluster {:?} ({col:?})", c.range);
            let y = ln.baseline - ln.ascent * 0.4;
            assert_eq!(l.hit_test(c.x + c.advance * 0.2, y), c.range.start, "{name}: left part of {:?}", c.range);
            assert_eq!(l.hit_test(c.x + c.advance * 0.8, y), c.range.end, "{name}: right part of {:?}", c.range);
            let (cx, top, bottom) = l.caret(c.range.start);
            assert!((cx - c.x).abs() < 1e-3 && top < y && bottom > y, "{name}: caret at {:?}", c.range);
        }
    }
}

fn runs_of(text: &str, styles: &[(usize, CharStyle)]) -> TextLayer {
    TextLayer { text: text.into(), runs: styles.iter().map(|(len, style)| TextRun { len: *len, style: style.clone() }).collect(), ..Default::default() }
}

/// Manual kerning (1/1000 em) after a character moves everything after it by kern × size.
#[test]
fn manual_kerning_moves_the_next_glyph() {
    use photocraft_doc::text::Kerning;
    let mut e = TextEngine::new();
    let s = CharStyle { size_pt: 100.0, ..Default::default() };
    let plain = e.layout(&styled("HOH", s.clone()), 72.0);
    let kerned = e.layout(&runs_of("HOH", &[(1, CharStyle { kern: 100.0, ..s.clone() }), (2, s.clone())]), 72.0);
    let x = |l: &crate::TextLayout, i: usize| l.glyphs[i].x;
    assert_eq!(x(&kerned, 0), x(&plain, 0));
    // 100/1000 em at 100 px = 10 px, for the next glyph and everything after it.
    assert!((x(&kerned, 1) - x(&plain, 1) - 10.0).abs() < 1e-3, "{} vs {}", x(&kerned, 1), x(&plain, 1));
    assert!((x(&kerned, 2) - x(&plain, 2) - 10.0).abs() < 1e-3);
    assert!((width(&kerned) - width(&plain) - 10.0).abs() < 1e-3);
    // Carets follow: the cluster after the kerned pair starts 10 px later.
    assert!((kerned.caret(1).0 - plain.caret(1).0 - 10.0).abs() < 1e-3);
    // Negative kerning tightens; kerning on the last character doesn't move anything.
    let tight = e.layout(&runs_of("HOH", &[(1, CharStyle { kern: -50.0, ..s.clone() }), (2, s.clone())]), 72.0);
    assert!((x(&tight, 1) - x(&plain, 1) + 5.0).abs() < 1e-3);
    let last = e.layout(&runs_of("HOH", &[(2, s.clone()), (1, CharStyle { kern: 500.0, ..s.clone() })]), 72.0);
    assert!((width(&last) - width(&plain)).abs() < 1e-3);
    // Off replaces the font's pair kerning: "AV" with Off is wider than with Metrics.
    let mut av = |st: CharStyle| e.layout(&styled("AV", st), 72.0).glyphs[1].x;
    let metric = av(s.clone());
    let off = av(CharStyle { kerning: Kerning::Off, ..s.clone() });
    assert!(off > metric + 1.0, "Inter kerns AV: {off} vs {metric}");
    // Centred point text stays centred around the anchor with kerning.
    let centred = with_para(
        runs_of("HOH", &[(1, CharStyle { kern: 300.0, ..s.clone() }), (2, s.clone())]),
        ParagraphStyle { align: TextAlign::Center, ..Default::default() },
    );
    let l = e.layout(&centred, 72.0);
    assert!((l.lines[0].x0 + l.lines[0].x1).abs() < 0.5, "{:?}", l.lines[0]);
}

/// Optical kerning computes pair spacing from the outlines: tighter for open pairs ("AV", "To")
/// than the unkerned advance, about neutral for straight stems, and never absurd.
#[test]
fn optical_kerning_tightens_open_pairs() {
    use photocraft_doc::text::Kerning;
    let mut e = TextEngine::new();
    let s = CharStyle { size_pt: 100.0, ..Default::default() };
    let gap = |e: &mut TextEngine, text: &str, k: Kerning| {
        let l = e.layout(&styled(text, CharStyle { kerning: k, ..s.clone() }), 72.0);
        l.glyphs[1].x - l.glyphs[0].x
    };
    for pair in ["AV", "To", "LT", "Ty"] {
        let off = gap(&mut e, pair, Kerning::Off);
        let optical = gap(&mut e, pair, Kerning::Optical);
        assert!(optical < off - 3.0, "{pair}: optical {optical} vs unkerned {off}");
    }
    for pair in ["HH", "nn", "oo", "HO"] {
        let off = gap(&mut e, pair, Kerning::Off);
        let optical = gap(&mut e, pair, Kerning::Optical);
        assert!((optical - off).abs() < 6.0, "{pair}: optical {optical} vs unkerned {off}");
    }
    // A space breaks the pair; a manual kern replaces the automatic one (as in Photoshop).
    assert_eq!(gap(&mut e, "A V", Kerning::Optical), gap(&mut e, "A V", Kerning::Off));
    for mode in [Kerning::Optical, Kerning::Metrics] {
        let l = e.layout(&styled("AV", CharStyle { kerning: mode, kern: 100.0, ..s.clone() }), 72.0);
        let off = gap(&mut e, "AV", Kerning::Off);
        assert!((l.glyphs[1].x - l.glyphs[0].x - off - 10.0).abs() < 1e-3, "{mode:?}");
    }
}

/// A mode change splits shaping runs: the pairs on both sides of a manually kerned character
/// lose their automatic kerning (Photoshop renders it the same way).
#[test]
fn kerning_modes_split_pairs() {
    use photocraft_doc::text::Kerning;
    let mut e = TextEngine::new();
    let s = CharStyle { size_pt: 100.0, ..Default::default() };
    let off = CharStyle { kerning: Kerning::Off, ..s.clone() };
    let xs = |e: &mut TextEngine, t: &TextLayer| e.layout(t, 72.0).glyphs.iter().map(|g| g.x).collect::<Vec<_>>();
    let metric = xs(&mut e, &styled("AVAV", s.clone()));
    let plain = xs(&mut e, &styled("AVAV", off.clone()));
    let mixed = xs(&mut e, &runs_of("AVAV", &[(2, s.clone()), (1, off.clone()), (1, s.clone())]));
    let adv = |v: &[f32], i: usize| v[i + 1] - v[i];
    assert!((adv(&mixed, 0) - adv(&metric, 0)).abs() < 1e-3, "AV before stays kerned");
    assert!((adv(&mixed, 1) - adv(&plain, 1)).abs() < 1e-3, "VA into the manual character");
    assert!((adv(&mixed, 2) - adv(&plain, 2)).abs() < 1e-3, "AV out of it");
}

#[test]
fn japanese_dictionary_word_boundaries() {
    // Use only the existing bundled Latin fonts: segmentation must not require a CJK font.
    let text = "私は学生です";
    let mut fonts = fonts::FontDb::new();
    let mut context = parley::LayoutContext::<[u8; 4]>::new();
    let mut layout = parley::Layout::new();
    let mut builder = context.ranged_builder(&mut fonts.fcx, text, 1.0, false);
    builder.push_default(parley::StyleProperty::FontFamily(parley::FontFamily::named("Inter")));
    // Suppress CJK line-break opportunities so these flags expose word boundaries alone.
    builder.push_default(parley::StyleProperty::WordBreak(parley::WordBreak::KeepAll));
    builder.build_into(&mut layout, text);
    layout.break_all_lines(None);
    let mut boundaries = Vec::new();
    for line in layout.lines() {
        for run in line.runs() {
            for cluster in run.clusters() {
                if cluster.is_word_boundary() {
                    boundaries.push(cluster.text_range().start);
                }
            }
        }
    }
    assert_eq!(boundaries, vec![0, 3, 6, 12]);
}

#[test]
fn japanese_box_text_preserves_wrap_boundaries() {
    let mut engine = TextEngine::new();
    let mut text = point("日本語の文章を折り返します。", 12.0);
    text.shape = TextShape::Box { x: 0.0, y: 0.0, width: 40.0, height: 1000.0 };
    let layout = engine.layout(&text, 72.0);
    assert!(layout.lines.len() > 1);
    let mut end = 0;
    for line in &layout.lines {
        assert_eq!(line.range.start, end);
        let content = text.text.get(line.range.clone()).expect("UTF-8 line boundaries");
        assert!(!content.starts_with('。'), "closing punctuation must stay with its preceding text");
        end = line.range.end;
    }
    assert_eq!(end, text.text.len());
}

/// #5959: Korean box text broke between Hangul syllables, mid-word ("설 / 정이나"). Lines break at
/// the spaces between words, as Photoshop sets Korean; a word longer than the box still breaks.
#[test]
fn korean_box_text_wraps_between_words() {
    let mut engine = TextEngine::new();
    let mut text = point("여기서는 각종 설정이나 캐릭터 제작을 진행합니다.", 12.0);
    text.shape = TextShape::Box { x: 0.0, y: 0.0, width: 60.0, height: 1000.0 };
    let layout = engine.layout(&text, 72.0);
    assert!(layout.lines.len() > 2, "{}", layout.lines.len());
    let words: Vec<&str> = text.text.split(' ').collect();
    for line in &layout.lines {
        let content = text.text.get(line.range.clone()).expect("UTF-8 line boundaries").trim();
        assert!(content.split(' ').all(|w| words.contains(&w)), "a line holds whole words only: {content:?}");
    }
    assert_eq!(super::layout::hangul_runs("a 한국어 b"), vec![2..11]);
}

/// Which craft-fonts family drew the glyphs of `l` (matched by the embedded bytes).
fn craft_family_of(l: &crate::TextLayout) -> Vec<&'static str> {
    let mut v = Vec::new();
    for g in &l.glyphs {
        let Some(face) = l.faces.get(g.face as usize) else { continue };
        let data: &[u8] = face.font.data.as_ref();
        if let Some(f) = crate::CRAFT_FONTS.iter().find(|f| std::ptr::eq(f.bytes.as_ptr(), data.as_ptr()) && f.bytes.len() == data.len())
            && !v.contains(&f.family)
        {
            v.push(f.family);
        }
    }
    v
}

#[test]
fn craft_fonts_cover_japanese_without_system_fonts() {
    if !crate::CRAFT_FONTS.iter().any(|f| f.is_japanese()) {
        eprintln!("skipping: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout)");
        return;
    }
    let mut e = TextEngine::new();
    let text = "日本語の文字、カタカナ。";
    let l = e.layout(&point(text, 24.0), 72.0);
    assert_eq!(l.glyphs.len(), text.chars().count());
    assert!(l.glyphs.iter().all(|g| g.id != 0), "no .notdef with craft-fonts");
    // Sans (Inter) runs fall back to the first CJK craft family in the UI locale's script order:
    // the Gothic UI family when Japanese leads that order or the build has no other CJK craft font.
    let cjk = |f: &crate::CraftFont| f.scripts.iter().any(|s| matches!(*s, "Jpan" | "Hans" | "Hant" | "Kore"));
    let first = e.fonts.fallback_stack().find_map(|fam| crate::CRAFT_FONTS.iter().find(|f| f.family == fam && cjk(f))).map(|f| f.family);
    if !crate::CRAFT_FONTS.iter().any(|f| cjk(f) && !f.is_japanese()) || crate::cjk::ui_script_order()[0] == crate::cjk::CjkScript::Japanese {
        assert_eq!(first, Some(crate::craft_fonts::UI_JAPANESE_FAMILY));
    }
    assert_eq!(craft_family_of(&l), first.into_iter().collect::<Vec<_>>());
    // Serif runs fall back to a Mincho face when the build has one (not the web build) and the
    // Japanese craft fonts come first.
    if first == Some(crate::craft_fonts::UI_JAPANESE_FAMILY) && crate::CRAFT_FONTS.iter().any(|f| f.is_mincho()) {
        let mut t = point(text, 24.0);
        t.font_family = "Times New Roman".into();
        let l = e.layout(&t, 72.0);
        assert!(l.glyphs.iter().all(|g| g.id != 0));
        let fams = craft_family_of(&l);
        assert!(fams.len() == 1 && fams[0].contains("Mincho"), "{fams:?}");
    }
    // Latin keeps Inter.
    let l = e.layout(&point("Layer 1", 24.0), 72.0);
    assert!(craft_family_of(&l).is_empty());
}

/// Chinese, Arabic and Thai set in Inter fall back to the craft font for their script when the
/// build has one (Noto Sans CJK SC, Noto Sans Arabic and Noto Sans Thai in newer craft-fonts).
#[test]
fn craft_fonts_cover_their_other_scripts_without_system_fonts() {
    let mut e = TextEngine::new();
    for (script, text) in [("Hans", "中文图层"), ("Arab", "مرحبا"), ("Thai", "ภาษาไทย")] {
        if !crate::CRAFT_FONTS.iter().any(|f| f.scripts.contains(&script)) {
            eprintln!("skipping {script}: built without a craft font for it (set CRAFT_FONTS_DIR to a craft-fonts checkout)");
            continue;
        }
        let l = e.layout(&point(text, 24.0), 72.0);
        assert!(!l.glyphs.is_empty() && l.glyphs.iter().all(|g| g.id != 0), "{script}: no .notdef with craft-fonts");
        let fams = craft_family_of(&l);
        assert!(fams.iter().any(|fam| crate::CRAFT_FONTS.iter().any(|f| f.family == *fam && f.scripts.contains(&script))), "{script}: drawn with {fams:?}");
    }
}

#[test]
fn works_without_craft_fonts() {
    // Whatever the build: the bundled fonts load, Latin lays out, and Japanese never panics
    // (without craft-fonts or system fonts it may be .notdef).
    let mut e = TextEngine::new();
    assert!(e.fonts.has_family("Inter"));
    let l = e.layout(&point("日本語 Latin", 12.0), 72.0);
    assert_eq!(l.glyphs.len(), "日本語 Latin".chars().count());
    for f in crate::CRAFT_FONTS {
        assert!(e.fonts.has_family(f.family), "{} registered under its manifest name", f.family);
    }
    if crate::CRAFT_FONTS.is_empty() {
        assert!(crate::craft_fonts::japanese_families().is_empty());
        let fb = fonts::fallback_candidates(&crate::cjk::script_order(Some("ja")));
        assert!(!fb.iter().any(|f| f.contains("BIZ UD")));
    }
}

#[test]
fn word_and_line_navigation() {
    use crate::layout::{byte_index, char_index, hit_char, line_edge, line_index, line_step, word_boundary};
    assert_eq!(word_boundary("hello big world", 0, true), 5);
    assert_eq!(word_boundary("hello big world", 7, false), 6);
    assert_eq!(word_boundary("hello big world", 15, false), 10);
    assert_eq!(word_boundary("hello", 0, false), 0);
    assert_eq!(word_boundary("hello", 5, true), 5);
    assert_eq!(word_boundary("", 4, true), 0);
    assert_eq!(word_boundary("ab", 100, true), 2);
    assert_eq!(word_boundary("ab, cd", 0, true), 2);
    assert_eq!(word_boundary("ab, cd", 2, true), 6);
    assert_eq!(word_boundary("Größe", 0, true), 5);

    let mut e = TextEngine::new();
    let text = "AäB\ncd";
    for vertical in [false, true] {
        let mut t = point(text, 20.0);
        if vertical {
            t.orientation = Orientation::Vertical;
        }
        let l = e.layout(&t, 72.0);
        let n = text.chars().count();
        for i in 0..=n {
            let b = byte_index(text, i);
            let [(x0, y0), (x1, y1)] = l.caret_segment(b);
            let (idx, line) = hit_char(&l, text, (x0 + x1) / 2.0, (y0 + y1) / 2.0);
            assert_eq!(idx, i, "vertical {vertical} index {i}");
            assert_eq!(line, line_index(&l, b), "vertical {vertical} index {i}");
        }
        assert!(l.lines.len() >= 2, "vertical {vertical}");
        let end0 = char_index(text, l.lines[0].range.end);
        let start1 = char_index(text, l.lines[1].range.start);
        assert_eq!(line_edge(&l, text, 1, true), end0, "vertical {vertical}");
        assert_eq!(line_edge(&l, text, 1, false), 0, "vertical {vertical}");
        assert_eq!(line_edge(&l, text, start1, false), start1, "vertical {vertical}");
        assert_eq!(line_edge(&l, text, start1, true), n, "vertical {vertical}");
        let x = l.caret(byte_index(text, 0)).0;
        let next = line_step(&l, text, 0, x, 1);
        assert!((start1..=n).contains(&next), "vertical {vertical} line_step -> {next}");
        assert_eq!(line_step(&l, text, 0, x, -1), 0, "vertical {vertical}");
        assert_eq!(line_step(&l, text, n, x, 1), n, "vertical {vertical}");
    }

    // A remembered column stays on the short line's start; the caret's own x falls off its end.
    let text = "WWWWWW\nI";
    let l = e.layout(&point(text, 30.0), 72.0);
    let end0 = line_edge(&l, text, 0, true);
    // end0 is the first line's end, which is not the second line. Step from there.
    let kept = line_step(&l, text, end0, l.caret(0).0, 1);
    let jumped = line_step(&l, text, end0, l.caret(byte_index(text, end0)).0, 1);
    assert_eq!(kept, char_index(text, l.lines[1].range.start), "kept column");
    assert_eq!(jumped, char_index(text, l.lines[1].range.end), "own column");
    assert!(jumped > kept);
}

#[test]
fn line_navigation_reaches_adjacent_line_with_large_leading() {
    use crate::layout::{byte_index, line_step};

    let mut e = TextEngine::new();
    let text = "ab\ncd";
    let mut t = point(text, 12.0);
    t.runs = vec![TextRun { len: text.len(), style: CharStyle { font_family: "Inter".into(), size_pt: 12.0, leading_pt: Some(40.0), ..Default::default() } }];
    let l = e.layout(&t, 72.0);

    assert_eq!(l.lines.len(), 2);
    assert!((l.lines[1].baseline - l.lines[0].baseline - 40.0).abs() < 0.01);
    let next = line_step(&l, text, 1, l.caret(byte_index(text, 1)).0, 1);
    assert_eq!(next, 4, "lineNext must reach the second line");
    let prev = line_step(&l, text, 4, l.caret(byte_index(text, 4)).0, -1);
    assert_eq!(prev, 1, "linePrev must reach the first line");
}

/// Thai text sample with above/below marks (sara i, mai ek, mai tho, mai han-akat, sara u).
const THAI_SAMPLE: &str = "ภาษาไทย สวัสดีครับ ผู้ที่น้ำ";

#[test]
fn thai_in_latin_font_falls_back_to_installed_thai_font() {
    // #1909: Thai typed in a Latin-only font (a newly chosen font has no PostScript name to find
    // the original Thai face) must fall back to an installed Thai-capable font, not .notdef.
    let mut e = TextEngine::with_system_fonts();
    let Some(thai) = fonts::THAI_FAMILIES.iter().find(|f| e.fonts.has_family(f)) else {
        eprintln!("skipped: no Thai-capable font installed");
        return;
    };
    let l = e.layout(&point(THAI_SAMPLE, 24.0), 72.0);
    assert!(!l.glyphs.is_empty());
    assert!(l.glyphs.iter().all(|g| g.id != 0), "Thai drawn with .notdef although {thai} is installed");
    // Latin next to Thai keeps the chosen font; only the Thai clusters fall back.
    let l = e.layout(&point("Thai ไทย", 24.0), 72.0);
    assert!(l.glyphs.iter().all(|g| g.id != 0));
    let (first, last) = (l.glyphs.first().map(|g| g.face), l.glyphs.last().map(|g| g.face));
    assert_ne!(first, last, "Latin and Thai drawn with the same face");
}

#[test]
fn thai_fallback_candidates_cover_every_platform() {
    // Logic-level half of #1909 (runs without Thai fonts): Windows, macOS and Linux each have a
    // Thai-capable family in the fallback candidates, ahead of the broad last-resort fonts.
    for order in [crate::cjk::script_order(None), crate::cjk::script_order(Some("ja"))] {
        let fb = fonts::fallback_candidates(&order);
        let last = fb.iter().position(|f| *f == "Arial Unicode MS").unwrap();
        for fam in ["Leelawadee UI", "Tahoma", "Thonburi", "Noto Sans Thai"] {
            let i = fb.iter().position(|f| *f == fam).unwrap_or_else(|| panic!("{fam} missing from {fb:?}"));
            assert!(i < last, "{fam} after the last-resort fonts");
        }
    }
}

/// The Southeast Asian scripts with their hard cases: Khmer coeng subscripts, the ah-sat mark and
/// numerals; Lao vowel and tone signs; Myanmar medials, stacks and dependent vowels (#218).
const SOUTHEAST_ASIAN: &[(&str, &str, &[&str])] = &[
    ("Khmer", "ភាសាខ្មែរ កម្ពុជា សួស្ដី រដ្ឋធម្ណុសាស្តៗ ១២៣", fonts::KHMER_FAMILIES),
    ("Lao", "ພາສາລາວ ສະບາຍດີ ຄ ໂລກ ຂອບໃຈ", fonts::LAO_FAMILIES),
    ("Myanmar", "မြန်မာဘာသာ မင်္ဂလာပါ ကျေးဇူးတင်ပါတယ်", fonts::MYANMAR_FAMILIES),
];

#[test]
fn southeast_asian_scripts_fall_back_to_installed_fonts() {
    // Detection and selection are tested apart, so a failure names its layer.
    for (name, sample, families) in SOUTHEAST_ASIAN {
        let mut e = TextEngine::with_system_fonts();
        let Some(hit) = families.iter().find(|f| e.fonts.has_family(f)) else {
            eprintln!("skipped: no {name}-capable font installed");
            continue;
        };
        // Layer 1, detection + loading + shaping: the installed family, asked for by name.
        let direct = TextLayer { text: (*sample).into(), font_family: hit.to_string(), size_pt: 24.0, ..Default::default() };
        let l = e.layout(&direct, 72.0);
        assert!(!l.glyphs.is_empty() && l.glyphs.iter().all(|g| g.id != 0), "{hit} is installed but shapes .notdef for {name}");
        // Layer 2, selection: the same text in a Latin-only font falls back instead of drawing
        // tofu, and the Latin around it keeps the chosen face.
        let mixed = format!("Latin {sample}");
        let l = e.layout(&point(&mixed, 24.0), 72.0);
        assert!(l.glyphs.iter().all(|g| g.id != 0), "{name} in a Latin font drawn with .notdef although {hit} is installed");
        let latin = l.glyphs.first().map(|g| g.face);
        assert!(l.glyphs.iter().any(|g| Some(g.face) != latin), "Latin and {name} drawn with the same face");
    }
}

#[test]
fn southeast_asian_fallback_candidates_cover_every_platform() {
    // Logic-level half of #218 (runs without these fonts): each script has a family for Windows,
    // macOS and Linux in the fallback candidates, ahead of the broad last-resort fonts.
    for order in [crate::cjk::script_order(None), crate::cjk::script_order(Some("ja"))] {
        let fb = fonts::fallback_candidates(&order);
        let last = fb.iter().position(|f| *f == "Arial Unicode MS").unwrap();
        for fam in [
            "Khmer UI",
            "Khmer Sangam MN",
            "Noto Sans Khmer",
            "Lao UI",
            "Lao Sangam MN",
            "Noto Sans Lao",
            "Myanmar Text",
            "Myanmar Sangam MN",
            "Noto Sans Myanmar",
        ] {
            let i = fb.iter().position(|f| *f == fam).unwrap_or_else(|| panic!("{fam} missing from {fb:?}"));
            assert!(i < last, "{fam} after the last-resort fonts");
        }
    }
}

/// The Indic scripts of document text, with conjuncts, matras and viramas (#218).
const INDIC: &[(&str, &str, &[&str])] = &[
    ("Devanagari", "हिन्दी भाषा क्षत्रिय श्री", fonts::DEVANAGARI_FAMILIES),
    ("Bengali", "বাংলা ভাষা ক্ষত্রিয় শ্রী", fonts::BENGALI_FAMILIES),
    ("Gurmukhi", "ਪੰਜਾਬੀ ਭਾਸ਼ਾ ਸਤਿ ਸ੍ਰੀ", fonts::GURMUKHI_FAMILIES),
    ("Gujarati", "ગુજરાતી ભાષા ક્ષત્રિય શ્રી", fonts::GUJARATI_FAMILIES),
    ("Tamil", "தமிழ் மொழி ஸ்ரீ கொடை", fonts::TAMIL_FAMILIES),
    ("Telugu", "తెలుగు భాష క్షత్రియ శ్రీ", fonts::TELUGU_FAMILIES),
    ("Kannada", "ಕನ್ನಡ ಭಾಷೆ ಕ್ಷತ್ರಿಯ ಶ್ರೀ", fonts::KANNADA_FAMILIES),
    ("Malayalam", "മലയാളം ഭാഷ ക്ഷത്രിയ ശ്രീ", fonts::MALAYALAM_FAMILIES),
    ("Sinhala", "සිංහල භාෂාව ක්‍ෂත්‍රිය ශ්‍රී", fonts::SINHALA_FAMILIES),
];

#[test]
fn indic_scripts_fall_back_to_installed_fonts() {
    for (name, sample, families) in INDIC {
        let mut e = TextEngine::with_system_fonts();
        let Some(hit) = families.iter().find(|f| e.fonts.has_family(f)) else {
            eprintln!("skipped: no {name}-capable font installed");
            continue;
        };
        let direct = TextLayer { text: (*sample).into(), font_family: hit.to_string(), size_pt: 24.0, ..Default::default() };
        let l = e.layout(&direct, 72.0);
        assert!(!l.glyphs.is_empty() && l.glyphs.iter().all(|g| g.id != 0), "{hit} is installed but shapes .notdef for {name}");
        let mixed = format!("Latin {sample}");
        let l = e.layout(&point(&mixed, 24.0), 72.0);
        assert!(l.glyphs.iter().all(|g| g.id != 0), "{name} in a Latin font drawn with .notdef although {hit} is installed");
        let latin = l.glyphs.first().map(|g| g.face);
        assert!(l.glyphs.iter().any(|g| Some(g.face) != latin), "Latin and {name} drawn with the same face");
    }
}

#[test]
fn indic_fallback_candidates_cover_every_platform() {
    // Logic-level half (runs without these fonts): every script has a Windows, macOS and Linux
    // family in the candidates, ahead of the broad last-resort fonts; the shared Nirmala UI is
    // probed once.
    for order in [crate::cjk::script_order(None), crate::cjk::script_order(Some("ja"))] {
        let fb = fonts::fallback_candidates(&order);
        let last = fb.iter().position(|f| *f == "Arial Unicode MS").unwrap();
        assert_eq!(fb.iter().filter(|f| **f == "Nirmala UI").count(), 1, "{fb:?}");
        for (name, _, families) in INDIC {
            assert!(families.contains(&"Nirmala UI"), "{name}");
            assert!(families.iter().any(|f| f.ends_with("Sangam MN") || f.starts_with("Kohinoor")), "{name}: no macOS family");
            assert!(families.iter().any(|f| f.starts_with("Noto Sans ")), "{name}: no Linux family");
            for fam in *families {
                let i = fb.iter().position(|f| f == fam).unwrap_or_else(|| panic!("{fam} missing from {fb:?}"));
                assert!(i < last, "{fam} after the last-resort fonts");
            }
        }
    }
}

#[test]
fn a_served_script_fallback_joins_the_fallback_stack_once_it_arrives() {
    let Some(cairo) = crate::CRAFT_FONTS.iter().find(|f| f.family == "Cairo") else {
        eprintln!("skipping: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout)");
        return;
    };
    crate::served::add_fonts(&crate::served::parse_manifest("Cairo | Regular | fonts/cairo/Cairo.ttf | Arab,Latn\n").0);
    let mut db = fonts::FontDb::new();
    assert!(!db.fallback_stack().any(|f| f == "Cairo"), "not before it arrives");
    db.register_font_data(cairo.bytes.to_vec());
    assert!(db.fallback_stack().any(|f| f == "Cairo"), "{:?}", db.fallback_stack().collect::<Vec<_>>());
}

/// #1317: Photoshop keeps the last line of a text box whose baseline is inside the box even
/// when its descenders hang below the bottom edge (three 35 pt lines of 25 pt type in a
/// 91.3 pt box). A line whose baseline falls outside the box is still dropped.
#[test]
fn box_lines_whose_descent_hangs_below_the_box_are_kept() {
    let mut e = TextEngine::new();
    let mut t = styled("one\ntwo\nthree", CharStyle { size_pt: 25.0, leading_pt: Some(35.0), ..Default::default() });
    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 91.27 };
    let l = e.layout(&t, 72.0);
    assert_eq!(l.lines.len(), 3, "{:?}", l.lines.iter().map(|l| l.baseline).collect::<Vec<_>>());
    assert!(l.lines[2].baseline <= 91.27 + 0.5);
    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: 300.0, height: 80.0 };
    assert_eq!(e.layout(&t, 72.0).lines.len(), 2, "the third baseline (about 88) is below an 80 pt box");
}

/// `Txt2` with one text object for `text` whose rendered frame is frame 0, and that frame:
/// for point text an anchor `point`, and a frame-to-text matrix `matrix` (recent Photoshop,
/// #1317).
fn txt2_with_frame(text: &str, point: Option<[f64; 2]>, matrix: [f64; 6]) -> Vec<u8> {
    let mut v = txt2_with_modes(text, &[(text.encode_utf16().count() + 1, 1)]);
    // Close the object's model early: `… >> >> ] >>` → `… >> /1 << /2 [ frame ] >> >> ] >>`.
    let tail = b"] >> >> >> ] >>";
    assert!(v.ends_with(tail));
    v.truncate(v.len() - tail.len());
    v.extend_from_slice(b"] >> >> /1 << /2 [ << /6 [ << /10 0 >> ] >> ] >> >> ] >>");
    let pt = point.map(|[x, y]| format!("/0 [ {x:.5} {y:.5} ] ")).unwrap_or_default();
    let m = matrix.map(|x| format!("{x:.5}")).join(" ");
    let frames = format!("/0 << /8 << /0 [ << /0 << {pt}/2 << /2 [ {m} ] >> >> >> ] >> >>");
    let at = v.windows(9).position(|w| w == b"/0 << >> ").unwrap();
    v.splice(at..at + 9, frames.into_bytes().into_iter().chain(*b" "));
    v
}

/// #1317: point text whose anchor Photoshop keeps only in its `Txt2` frame (EngineData's
/// `PointBase` at the origin, the transform far away) is placed at that anchor, not at the
/// ink's top left. A rewritten `TySh` (bounds near the origin) is left alone.
#[test]
fn txt2_frame_places_point_text_at_its_anchor() {
    let mut t = point("2", 100.0);
    t.transform = Affine::translate(-1000.0, -2000.0);
    // Photoshop's text space: anchor at (1100, 2050), ink above its baseline.
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, Some([1100.0, 1980.0, 1160.0, 2050.0])), 0);
    let txt2 = crate::psd::parse_txt2(&txt2_with_frame("2", Some([1000.0, 2100.0]), [1.0, 0.0, 0.0, 1.0, 100.0, -50.0])).unwrap();
    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    crate::psd::apply_txt2_frame(&mut l, &tysh, &txt2);
    let o = l.transform.apply(photocraft_geom::Point::new(0.0, 0.0));
    assert!((o.x - 100.0).abs() < 1e-3 && (o.y - 50.0).abs() < 1e-3, "anchor at {o:?}");
    // Already folded in (bounds near the origin): unchanged; another text: unchanged.
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, Some([0.0, -70.0, 60.0, 0.0])), 0);
    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    let before = l.transform;
    crate::psd::apply_txt2_frame(&mut l, &tysh, &txt2);
    assert_eq!(l.transform, before);
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, Some([1100.0, 1980.0, 1160.0, 2050.0])), 0);
    let other = crate::psd::parse_txt2(&txt2_with_frame("3", Some([1000.0, 2100.0]), [1.0, 0.0, 0.0, 1.0, 100.0, -50.0])).unwrap();
    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    let before = l.transform;
    crate::psd::apply_txt2_frame(&mut l, &tysh, &other);
    assert_eq!(l.transform, before);
}

/// `tysh` with its text-space `bounds` set to `r` (Photoshop's, where it drew the text).
fn with_bounds(tysh: &[u8], r: [f64; 4]) -> Vec<u8> {
    use photocraft_psd::descriptor::{Descriptor, Id, Value};
    let mut t = crate::psd::parse_tysh(tysh).unwrap();
    let mut d = Descriptor::default();
    for (k, v) in ["Left", "Top ", "Rght", "Btom"].iter().zip(r) {
        d.items.push((Id::new(k), Value::Double(v)));
    }
    t.text.items.retain(|(k, _)| !k.is("bounds"));
    t.text.items.push((Id::new("bounds"), Value::Descriptor(d)));
    crate::psd::write_tysh(&t)
}

/// #1317: a text box whose `BoxBounds` are in its `Txt2` frame's space is moved by the frame's
/// matrix onto the `bounds` Photoshop drew it at (it used to land off the canvas, so its text
/// "disappeared" when an edit started).
#[test]
fn txt2_frame_moves_box_text_onto_its_bounds() {
    let mut t = styled("Casemiro 45", CharStyle { size_pt: 25.0, ..Default::default() });
    t.shape = TextShape::Box { x: 500.0, y: 600.0, width: 300.0, height: 90.0 };
    t.transform = Affine::translate(-700.0, -300.0);
    let built = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), 0);
    let tysh = with_bounds(&built, [960.0, 300.0, 1260.0, 390.0]);
    let txt2 = crate::psd::parse_txt2(&txt2_with_frame("Casemiro 45", None, [1.0, 0.0, 0.0, 1.0, 460.0, -300.0])).unwrap();
    let mut l = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    assert!(matches!(l.shape, TextShape::Box { .. }));
    crate::psd::apply_txt2_frame(&mut l, &tysh, &txt2);
    let TextShape::Box { x, y, .. } = l.shape else { panic!("not a box") };
    let o = l.transform.apply(photocraft_geom::Point::new(f64::from(x), f64::from(y)));
    assert!((o.x - 260.0).abs() < 1e-3 && (o.y - 0.0).abs() < 1e-3, "box top left at {o:?}");
    // PhotoCraft's own `TySh` (bounds = the box, frame already folded in): unchanged.
    let mut l = crate::psd::text_layer_from_tysh(&built, 72.0).unwrap();
    let before = l.transform;
    crate::psd::apply_txt2_frame(&mut l, &built, &txt2);
    assert_eq!(l.transform, before);
}

/// Preferences ▸ Type ▸ Missing Glyph Protection: off, only the default family is in the
/// fallback stack, so a face without the glyph shows the missing-glyph box instead of a
/// fallback's glyph (#1909).
#[test]
fn missing_glyph_protection_can_turn_the_fallback_stack_off() {
    let Some(cairo) = crate::CRAFT_FONTS.iter().find(|f| f.family == "Cairo") else {
        eprintln!("skipping: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout)");
        return;
    };
    let mut db = fonts::FontDb::new();
    db.register_font_data(cairo.bytes.to_vec());
    assert!(db.missing_glyph_protection(), "on by default, as in Photoshop");
    assert!(db.fallback_stack().any(|f| f == "Cairo"));
    db.set_missing_glyph_protection(false);
    assert_eq!(db.fallback_stack().collect::<Vec<_>>(), [fonts::DEFAULT_FAMILY], "only the default family remains");
    db.set_missing_glyph_protection(true);
    assert!(db.fallback_stack().any(|f| f == "Cairo"), "turning it back on restores the coverage fonts");
}

/// The shared engine's missing-glyph protection follows the setting without waiting for the
/// system font scan (#4519). Under test the shared engine has no scan, so it applies at once;
/// the newest setting wins.
#[test]
fn shared_missing_glyph_protection_follows_the_setting() {
    let read = || crate::shared().lock().unwrap_or_else(std::sync::PoisonError::into_inner).fonts.missing_glyph_protection();
    crate::set_shared_missing_glyph_protection(false);
    assert!(!read());
    crate::set_shared_missing_glyph_protection(true);
    crate::set_shared_missing_glyph_protection(false);
    assert!(!read(), "the newest setting wins");
    crate::set_shared_missing_glyph_protection(true);
    assert!(read());
}

#[test]
fn translate_tysh_moves_only_the_translation() {
    let mut t = point("Hello!", 26.0);
    t.transform = Affine { m: [1.5, 0.0, 0.0, 1.5, 80.0, 340.0] };
    let tysh = crate::psd::build_tysh(&t, 72.0, Some([0.0, -20.0, 300.0, 4.0]));
    let moved = crate::psd::translate_tysh(&tysh, -8.0, -279.0).unwrap();
    let back = crate::psd::parse_tysh(&moved).unwrap();
    assert_eq!(back.transform.m, [1.5, 0.0, 0.0, 1.5, 72.0, 61.0]);
    // Everything but the 16 translation bytes is unchanged.
    assert_eq!(moved.len(), tysh.len());
    assert_eq!((&moved[..34], &moved[50..]), (&tysh[..34], &tysh[50..]));
    assert_eq!(crate::psd::parse_tysh(&tysh).unwrap().bounds, back.bounds, "bounds are in text space");
    assert!(crate::psd::translate_tysh(&tysh[..40], 1.0, 1.0).is_none(), "a truncated block is refused");
}

/// The four values after the `TySh` warp descriptor are big-endian f32, as Photoshop writes them:
/// zeros for unwarped type, the text-space bounds for warped type.
#[test]
fn tysh_trailing_bounds_are_f32() {
    use photocraft_doc::text::TextWarp;
    let tail = |b: &[u8]| -> [f32; 4] {
        let t = b.get(b.len() - 16..).unwrap();
        std::array::from_fn(|i| f32::from_be_bytes(t[i * 4..i * 4 + 4].try_into().unwrap()))
    };
    let ink = [0.0, -34.316406, 288.90625, 15.058594];
    let plain = crate::psd::build_tysh(&point("Type", 20.0), 72.0, Some(ink));
    assert_eq!(tail(&plain), [0.0; 4]);
    let warped = TextLayer {
        warp: Some(TextWarp { style: "warpArc".into(), value: 50.0, horizontal_distortion: 0.0, vertical_distortion: 0.0, horizontal: true }),
        ..point("Type", 20.0)
    };
    let bytes = crate::psd::build_tysh(&warped, 72.0, Some(ink));
    assert_eq!(tail(&bytes), ink);
    let parsed = crate::psd::parse_tysh(&bytes).unwrap();
    assert_eq!(parsed.bounds, ink);
    assert_eq!(crate::psd::write_tysh(&parsed), bytes);
}

/// EngineData's `AntiAlias` numbers as Photoshop writes them, beside the `AntA` descriptor:
/// 0 None, 1 Crisp, 2 Strong, 3 Smooth, 4 Sharp. Read back from EngineData alone (no `AntA`),
/// every mode survives.
#[test]
fn engine_data_antialias_numbers_match_photoshop() {
    use photocraft_doc::text::AntiAlias;
    for (mode, n) in [(AntiAlias::None, 0), (AntiAlias::Crisp, 1), (AntiAlias::Strong, 2), (AntiAlias::Smooth, 3), (AntiAlias::Sharp, 4)] {
        let t = TextLayer { antialias: mode, ..point("Type", 20.0) };
        let mut tysh = crate::psd::parse_tysh(&crate::psd::build_tysh(&t, 72.0, None)).unwrap();
        let e = crate::psd::engine_data(&tysh.text).unwrap();
        assert_eq!(e.path(&["EngineDict", "AntiAlias"]).and_then(crate::engine_data::Value::as_f64), Some(f64::from(n)), "{mode:?}");
        tysh.text.items.retain(|(k, _)| !k.is("AntA"));
        let back = crate::psd::text_layer_from_tysh(&crate::psd::write_tysh(&tysh), 72.0).unwrap();
        assert_eq!(back.antialias, mode, "{n}");
    }
}

/// Anti-alias modes must change edge coverage (storytold/photocraft#5902).
#[test]
fn antialias_modes_change_edge_fringe() {
    use photocraft_doc::text::AntiAlias;

    let fringe_mass = |mode: AntiAlias| {
        let mut e = TextEngine::new();
        let layer = TextLayer { antialias: mode, ..point("O", 48.0) };
        let (_, r) = e.render(&layer, 72.0, PixelFormat::RGBA8);
        let n = r.surface.channels();
        r.surface.read_region(r.rect).chunks_exact(n).map(|p| f64::from(p[n - 1])).filter(|&a| a > 0.02 && a < 0.98).sum::<f64>()
    };

    let none = fringe_mass(AntiAlias::None);
    let sharp = fringe_mass(AntiAlias::Sharp);
    let smooth = fringe_mass(AntiAlias::Smooth);
    let strong = fringe_mass(AntiAlias::Strong);

    assert_eq!(none, 0.0, "aliased-off edges are hard");
    assert!(strong > smooth + 1.0, "strong smooths more than smooth: {strong} vs {smooth}");
    assert!(smooth > sharp + 0.5, "sharp thins the fringe vs smooth: {sharp} vs {smooth}");
    assert!(sharp > 0.0);
}

/// Type on a path (#218): along a vertical line the type runs top to bottom with its glyphs
/// turned, along a curve it follows the curve, and glyphs beyond the end are not drawn.
#[test]
fn type_on_a_path_follows_the_curve() {
    use photocraft_doc::vector::{Knot, Subpath};
    let fmt = PixelFormat::RGBA8;
    let mut eng = TextEngine::new();
    let ink = |eng: &mut TextEngine, t: &TextLayer| {
        let (_, r) = eng.render(t, 72.0, fmt);
        r.rect
    };
    let straight = point("Path text", 24.0);
    let flat = ink(&mut eng, &straight);
    assert!(flat.width() > flat.height() * 3, "{flat:?}");

    let mut down = straight.clone();
    down.shape = TextShape::Path { path: Subpath::polyline(&[(0.0, 0.0), (0.0, 400.0)]), start: 0.0, flip: false };
    let r = ink(&mut eng, &down);
    assert!(r.height() > r.width() * 3, "vertical path gives tall ink: {r:?}");
    assert!(r.height() >= flat.width() - 8, "arc length is preserved: {r:?} vs {flat:?}");

    // A half circle bends the text through a larger area than the straight line.
    let k = 0.5523 * 60.0;
    let arc = Subpath {
        closed: false,
        knots: vec![
            Knot {
                anchor: photocraft_geom::Point::new(-60.0, 0.0),
                in_ctrl: photocraft_geom::Point::new(-60.0, 0.0),
                out_ctrl: photocraft_geom::Point::new(-60.0, -k),
                smooth: true,
            },
            Knot {
                anchor: photocraft_geom::Point::new(0.0, -60.0),
                in_ctrl: photocraft_geom::Point::new(-k, -60.0),
                out_ctrl: photocraft_geom::Point::new(k, -60.0),
                smooth: true,
            },
            Knot {
                anchor: photocraft_geom::Point::new(60.0, 0.0),
                in_ctrl: photocraft_geom::Point::new(60.0, -k),
                out_ctrl: photocraft_geom::Point::new(60.0, 0.0),
                smooth: true,
            },
        ],
        ..Default::default()
    };
    let mut curved = straight.clone();
    curved.shape = TextShape::Path { path: arc.clone(), start: 0.0, flip: false };
    let c = ink(&mut eng, &curved);
    assert!(c.height() > flat.height() * 2, "curved ink is taller: {c:?} vs {flat:?}");

    // A path too short for the text hides the glyphs past its end.
    let mut short = straight.clone();
    short.shape = TextShape::Path { path: Subpath::polyline(&[(0.0, 0.0), (30.0, 0.0)]), start: 0.0, flip: false };
    assert!(ink(&mut eng, &short).width() < flat.width() / 2);
    // A degenerate path falls back to straight point text instead of failing.
    let mut dot = straight.clone();
    dot.shape = TextShape::Path { path: Subpath::polyline(&[(5.0, 5.0), (5.0, 5.0)]), start: 0.0, flip: false };
    assert_eq!(ink(&mut eng, &dot), flat);
}

#[test]
fn hyphenless_postscript_names_split_trailing_styles() {
    for (ps, family, weight, italic) in [
        ("GmarketSansBold", "Gmarket Sans", 700, false),
        ("NanumGothicBold", "Nanum Gothic", 700, false),
        ("GmarketSansTTFBold", "Gmarket Sans TTF", 700, false),
        ("ExampleSansSemiBoldItalic", "Example Sans", 600, true),
        ("ExampleSansExtraLight", "Example Sans", 200, false),
        // A style word after a vendor tag belongs to a legacy family name; lowercase is no style.
        ("ArialRoundedMTBold", "Arial Rounded MT Bold", 400, false),
        ("Daylight", "Daylight", 400, false),
    ] {
        let r = fonts::guess_from_postscript(ps);
        assert_eq!((r.family.as_str(), r.weight, r.italic), (family, weight, italic), "{ps}");
    }
}

/// Thickening moves each outline point along its bisector; this guards that curves stay as smooth
/// as the regular glyph's at a large size (the bend of a bold "O"'s edge between rows matches the
/// regular one's). See also `faux_bold_keeps_square_corners_square`.
#[test]
fn faux_bold_curves_stay_smooth_at_large_sizes() {
    let mut e = TextEngine::new();
    // The largest bend of the left edge between consecutive rows, in pixels (second difference
    // of its sub-pixel position), over the middle of the glyph's height.
    let bumpiness = |e: &mut TextEngine, bold: bool| -> f64 {
        let style = CharStyle { size_pt: 600.0, faux_bold: bold, ..Default::default() };
        let (_, r) = e.render(&TextLayer { transform: Affine::translate(60.0, 640.0), ..styled("O", style) }, 72.0, PixelFormat::RGBA8);
        let alpha = |x: i32, y: i32| alpha_sum(&r.surface, photocraft_geom::Rect::new(x, y, x + 1, y + 1));
        let h = r.rect.height() as i32;
        let mut edges = Vec::new();
        for y in (r.rect.y0 + h * 15 / 100)..(r.rect.y0 + h * 85 / 100) {
            if let Some(x) = (r.rect.x0..r.rect.x1).find(|&x| alpha(x, y) > 0.01) {
                edges.push(f64::from(x) + 1.0 - alpha(x, y));
            }
        }
        edges.windows(3).map(|w| (w[2] - 2.0 * w[1] + w[0]).abs()).fold(0.0, f64::max)
    };
    let plain = bumpiness(&mut e, false);
    let bold = bumpiness(&mut e, true);
    eprintln!("bumpiness plain {plain} bold {bold}");
    assert!(bold < plain + 0.5, "faux bold's edge is notched: bends {bold} px vs {plain} px regular");
}

/// The notches showed most at corners and stroke ends: eight stamped copies leave a stepped bite
/// out of a square corner. Thickened outlines keep corners square, as a bold "l" shows.
#[test]
fn faux_bold_keeps_square_corners_square() {
    let mut e = TextEngine::new();
    for bold in [false, true] {
        let style = CharStyle { size_pt: 600.0, faux_bold: bold, ..Default::default() };
        let (_, r) = e.render(&TextLayer { transform: Affine::translate(60.0, 640.0), ..styled("l", style) }, 72.0, PixelFormat::RGBA8);
        let alpha = |x: i32, y: i32| alpha_sum(&r.surface, photocraft_geom::Rect::new(x, y, x + 1, y + 1));
        // The ink's own top-left and top-right corners (the raster rect pads the ink by a pixel).
        let top = (r.rect.y0..r.rect.y1).find(|&y| (r.rect.x0..r.rect.x1).any(|x| alpha(x, y) > 0.5)).unwrap();
        let left = (r.rect.x0..r.rect.x1).find(|&x| (r.rect.y0..r.rect.y1).any(|y| alpha(x, y) > 0.5)).unwrap();
        let right = (r.rect.x0..r.rect.x1).rev().find(|&x| (r.rect.y0..r.rect.y1).any(|y| alpha(x, y) > 0.5)).unwrap();
        for (x, corner) in [(left + 1, "top-left"), (right - 1, "top-right")] {
            let a = alpha(x, top + 1);
            assert!(a > 0.9, "bold {bold}: the {corner} corner is cut away (alpha {a})");
        }
    }
}

#[test]
fn text_rebuild_preserves_imported_font_metadata() {
    use crate::engine_data::Value as E;
    let layer = point("Original", 24.0);
    let mut template = crate::psd::build_engine_data(&layer, None, 72.0);
    for key in ["ResourceDict", "DocumentResources"] {
        let fonts = template.get_mut(key).unwrap().get_mut("FontSet").unwrap();
        let E::Array(fonts) = fonts else { panic!("font array") };
        for font in fonts.iter_mut() {
            font.set("Script", E::Int(4));
            font.set("FontType", E::Int(2));
            font.set("Synthetic", E::Int(3));
            font.set("PrivateFontFlag", E::Int(17));
        }
    }
    let expected = template.path(&["ResourceDict", "FontSet"]).unwrap().clone();
    let mut edited = layer;
    edited.text = "Edited".into();
    let rebuilt = crate::psd::build_engine_data(&edited, Some(template), 72.0);
    for key in ["ResourceDict", "DocumentResources"] {
        assert_eq!(rebuilt.path(&[key, "FontSet"]), Some(&expected), "existing font metadata must survive a text edit");
    }
}

#[test]
fn font_metadata_survives_tysh_and_named_style_rewrites() {
    use crate::engine_data::Value as E;
    let source = point("Original", 24.0);
    let mut tysh = crate::psd::parse_tysh(&crate::psd::build_tysh(&source, 72.0, None)).unwrap();
    let mut data = crate::psd::engine_data(&tysh.text).unwrap();
    for (key, marker) in [("ResourceDict", 17), ("DocumentResources", 29)] {
        let E::Array(fonts) = data.get_mut(key).unwrap().get_mut("FontSet").unwrap() else { panic!("font array") };
        for font in fonts {
            font.set("PrivateFontFlag", E::Int(marker));
            font.set("Script", E::Int(4));
        }
    }
    for (key, value) in &mut tysh.text.items {
        if key.as_bytes() == b"EngineData" {
            *value = photocraft_psd::descriptor::Value::RawData(crate::engine_data::write(&data));
        }
    }
    let raw = crate::psd::write_tysh(&tysh);
    let mut imported = crate::psd::text_layer_from_tysh(&raw, 72.0).unwrap();
    // The IO importer retains the raw block separately from the parsed text model.
    imported.psd_raw = Some(raw.into());
    imported.text = "Edited".into();
    let rebuilt = crate::psd::build_tysh(&imported, 72.0, None);
    let styled = crate::psd_styles::write_style_sheets(&rebuilt, &imported, &photocraft_doc::TextStyles::default(), 72.0).unwrap();
    for bytes in [&rebuilt, &styled] {
        let parsed = crate::psd::parse_tysh(bytes).unwrap();
        let actual = crate::psd::engine_data(&parsed.text).unwrap();
        for key in ["ResourceDict", "DocumentResources"] {
            assert_eq!(actual.path(&[key, "FontSet"]), data.path(&[key, "FontSet"]));
        }
        assert_eq!(crate::psd::text_layer_from_tysh(bytes, 72.0).unwrap().text, "Edited");
    }
}

#[test]
fn font_metadata_append_reorder_and_duplicate_indices() {
    use crate::engine_data::Value as E;
    let record = |name: &str, marker| E::Dict(vec![("Name".into(), E::String(name.into())), ("PrivateFontFlag".into(), E::Int(marker))]);
    let entries = vec![record("A", 1), record("A", 2), record("B", 3)];
    let original = E::Array(entries.clone());
    let names = ["A", "A", "B", "New"].map(str::to_string);
    let result = crate::psd::font_set(&names, Some(&original));
    let fonts = result.as_array().unwrap();
    assert_eq!(&fonts[..3], entries.as_slice());
    assert_eq!(fonts[3], crate::psd::font_entry("New"));
    let reordered = crate::psd::font_set(&["B".into(), "A".into()], Some(&original));
    assert_eq!(reordered, E::Array(vec![entries[2].clone(), entries[1].clone()]));
    // A non-positional duplicate uses the first matching record, not the last map insertion.
    let fallback = crate::psd::font_set(&["New".into(), "B".into(), "A".into()], Some(&original));
    assert_eq!(fallback, E::Array(vec![crate::psd::font_entry("New"), entries[2].clone(), entries[0].clone()]));
    let empty = record("", 9);
    assert_eq!(crate::psd::font_set(&["".into()], Some(&E::Array(vec![E::Int(0), empty.clone()]))), E::Array(vec![empty]));
    for malformed in [None, Some(&E::Int(0))] {
        assert_eq!(crate::psd::font_set(&["New".into()], malformed), E::Array(vec![crate::psd::font_entry("New")]));
    }
}

#[test]
fn font_metadata_large_nameless_lists_rebuild_after_edit() {
    use crate::engine_data::Value as E;
    let mut layer = point("Original", 24.0);
    let mut template = crate::psd::build_engine_data(&layer, None, 72.0);
    for key in ["ResourceDict", "DocumentResources"] {
        template.get_mut(key).unwrap().set("FontSet", E::Array(vec![E::Int(0); 10_000]));
    }
    layer.text = "Edited".into();
    let rebuilt = crate::psd::build_engine_data(&layer, Some(template), 72.0);
    for key in ["ResourceDict", "DocumentResources"] {
        let fonts = rebuilt.path(&[key, "FontSet"]).unwrap().as_array().unwrap();
        assert!(fonts.len() >= 10_000);
        assert!(fonts[..10_000].iter().all(|font| *font == crate::psd::font_entry("")));
    }
}

#[test]
fn font_metadata_reordered_duplicates_keep_distinct_dictionary_records() {
    use crate::engine_data::Value as E;
    let record = |name: &str, marker| E::Dict(vec![("Name".into(), E::String(name.into())), ("PrivateFontFlag".into(), E::Int(marker))]);
    let mut layer = point("Original", 24.0);
    let mut template = crate::psd::build_engine_data(&layer, None, 72.0);
    let resource = vec![record("A", 1), record("A", 2), record("B", 3)];
    let document = vec![record("B", 30), record("A", 10), record("A", 20)];
    template.get_mut("ResourceDict").unwrap().set("FontSet", E::Array(resource.clone()));
    template.get_mut("DocumentResources").unwrap().set("FontSet", E::Array(document.clone()));
    layer.text = "Edited".into();
    let rebuilt = crate::psd::build_engine_data(&layer, Some(template), 72.0);
    assert_eq!(&rebuilt.path(&["ResourceDict", "FontSet"]).unwrap().as_array().unwrap()[..3], resource.as_slice());
    let fonts = rebuilt.path(&["DocumentResources", "FontSet"]).unwrap().as_array().unwrap();
    assert_eq!(&fonts[..3], &[document[1].clone(), document[2].clone(), document[0].clone()], "reordered duplicates must keep distinct metadata");
    let repeated = crate::psd::font_set(&["A", "A", "A", "A"].map(str::to_string), Some(&E::Array(resource.clone())));
    assert_eq!(repeated, E::Array(vec![resource[0].clone(), resource[1].clone(), resource[0].clone(), resource[0].clone()]));
}

/// Same-runner release probe: compare the original and repaired source, not a wall-clock CI limit.
#[test]
#[ignore = "release performance measurement for large imported FontSets"]
fn font_metadata_large_lists_timing() {
    use crate::engine_data::Value as E;
    for reordered in [false, true] {
        let mut layer = point("Original", 24.0);
        let mut template = crate::psd::build_engine_data(&layer, None, 72.0);
        let n = 100_000;
        for key in ["ResourceDict", "DocumentResources"] {
            let entries = if reordered {
                (0..n).map(|i| crate::psd::font_entry(&format!("Font{}", if key == "DocumentResources" { n - 1 - i } else { i }))).collect()
            } else {
                vec![E::Int(0); n]
            };
            template.get_mut(key).unwrap().set("FontSet", E::Array(entries));
        }
        layer.text = "Edited".into();
        let mut times = Vec::new();
        for _ in 0..3 {
            let input = template.clone();
            let start = std::time::Instant::now();
            let result = crate::psd::build_engine_data(&layer, Some(input), 72.0);
            std::hint::black_box(&result);
            times.push(start.elapsed().as_secs_f64());
        }
        times.sort_by(f64::total_cmp);
        println!("FONT_LOOKUP reordered={reordered} n={n} median_seconds={}", times[1]);
    }
}

/// A word wider than its paragraph box wraps at the box edge instead of running past it (#6694);
/// a normal break opportunity still wins, and a box that fits the word lays out exactly as before.
#[test]
fn a_word_wider_than_the_paragraph_box_breaks_at_the_box_edge() {
    let mut e = TextEngine::new();
    let word = "BLOQUEADO?!";
    let alone = e.layout(&point(word, 12.0), 72.0);
    assert_eq!(alone.lines.len(), 1, "{:?}", alone.lines);
    let word_width = width(&alone);
    let narrow = 30.0;
    assert!(word_width > narrow * 2.0, "{word_width}");

    let mut t = point(word, 12.0);
    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: narrow, height: 200.0 };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 2, "{:?}", l.lines);
    for line in &l.lines {
        assert!(line.x1 <= narrow + 0.5, "{line:?}");
    }
    let joined: String = l.lines.iter().map(|l| &word[l.range.clone()]).collect();
    assert_eq!(joined, word);

    t.shape = TextShape::Box { x: 0.0, y: 0.0, width: word_width + 20.0, height: 200.0 };
    let fits = e.layout(&t, 72.0);
    assert_eq!(fits.lines.len(), 1, "{:?}", fits.lines);
    assert!((width(&fits) - word_width).abs() < 0.01, "{} vs {word_width}", width(&fits));

    let mut spaced = point("ab cd", 12.0);
    spaced.shape = TextShape::Box { x: 0.0, y: 0.0, width: narrow, height: 200.0 };
    let l = e.layout(&spaced, 72.0);
    assert_eq!(l.lines.len(), 2, "{:?}", l.lines);
    assert_eq!(l.lines[1].range.start, 3, "{:?}", l.lines);
}

/// [`TextLayout::overflows`] reads dropped lines off the layout: text that fits covers its end
/// through trailing empty paragraphs; a taller text's lines stop short of the text's end; an
/// empty uncovered tail of pure trailing breaks that fit is not an overflow.
#[test]
fn overflows_says_whether_a_box_holds_its_text() {
    let mut e = TextEngine::new();
    let tall_box = TextShape::Box { x: 0.0, y: 0.0, width: 220.0, height: 900.0 };
    // Everything fits, trailing breaks included: the trailing empty paragraphs cover the
    // text's end.
    for text in ["a", "a\n", "a\n\n", "", "Lorem ipsum dolor sit amet"] {
        let l = e.layout(&TextLayer { shape: tall_box.clone(), ..point(text, 24.0) }, 72.0);
        assert!(!l.overflows(text), "{text:?}: {} lines", l.lines.len());
    }
    // The box holds one line of 24 pt type — additional lines are dropped, and the last line
    // stops short of the text.
    let short_box = TextShape::Box { x: 0.0, y: 0.0, width: 220.0, height: 34.0 };
    let text = "ab\ncd\nef";
    let l = e.layout(&TextLayer { shape: short_box.clone(), ..point(text, 24.0) }, 72.0);
    assert!(l.overflows(text), "{:?}", l.lines.last().map(|ln| ln.range.clone()));
    // A trailing break whose empty paragraph doesn't fit is an overflow as well.
    let l = e.layout(&TextLayer { shape: short_box.clone(), ..point("ab\n\n", 24.0) }, 72.0);
    assert!(l.overflows("ab\n\n"), "{:?}", l.lines.last().map(|ln| ln.range.clone()));
    // A box holding one full line plus exactly one more empty paragraph is not.
    let exact = point("ab\n", 24.0);
    let l = e.layout(&TextLayer { shape: tall_box.clone(), ..exact }, 72.0);
    assert!(!l.overflows("ab\n"), "{:?}", l.lines.last().map(|ln| ln.range.clone()));
    // Empty text never overflows: even a box too short for its paragraph (no lines laid out)
    // has nothing to lose, so no overflow mark.
    let l = e.layout(&TextLayer { shape: short_box.clone(), ..point("", 24.0) }, 72.0);
    assert!(!l.overflows(""), "{} lines", l.lines.len());
    let _ = &mut e;
}

/// Closed polygon in text space.
fn area_poly(pts: &[(f64, f64)]) -> photocraft_doc::vector::Path {
    photocraft_doc::vector::Path::new(vec![photocraft_doc::vector::Subpath::polygon(pts)])
}

/// An ellipse from four kappa curves inside `[x, y, w, h]`.
fn area_ellipse(x: f64, y: f64, w: f64, h: f64) -> photocraft_doc::vector::Path {
    use photocraft_doc::vector::{Knot, Subpath};
    use photocraft_geom::Point;
    let (rx, ry, cx, cy) = (w / 2.0, h / 2.0, x + w / 2.0, y + h / 2.0);
    let (kx, ky) = (0.552_284_75 * rx, 0.552_284_75 * ry);
    let p = Point::new;
    let knots = vec![
        Knot::smooth(p(cx, y), p(cx - kx, y), p(cx + kx, y)),
        Knot::smooth(p(x + w, cy), p(x + w, cy - ky), p(x + w, cy + ky)),
        Knot::smooth(p(cx, y + h), p(cx + kx, y + h), p(cx - kx, y + h)),
        Knot::smooth(p(x, cy), p(x, cy + ky), p(x, cy - ky)),
    ];
    photocraft_doc::vector::Path::new(vec![Subpath { closed: true, knots, op: Default::default() }])
}

const BUBBLE_TEXT: &str = "Well, that went better than expected. Now where did the cat hide the keys this time?";

/// Every laid-out line sits inside a span of the shape across its band.
fn assert_lines_inside(l: &crate::TextLayout, path: &photocraft_doc::vector::Path) {
    let a = crate::area::AreaShape::new(path, false).unwrap();
    for line in &l.lines {
        let spans = a.spans(line.baseline - line.ascent, line.baseline + line.descent, 0.0);
        assert!(spans.iter().any(|&(s0, s1)| line.x0 >= s0 - 0.5 && line.x1 <= s1 + 0.5), "{line:?} not inside {spans:?}");
    }
}

#[test]
fn area_text_stays_inside_an_ellipse() {
    let mut e = TextEngine::new();
    let mut t = point(BUBBLE_TEXT, 18.0);
    let path = area_ellipse(0.0, 0.0, 260.0, 160.0);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 4, "{}", l.lines.len());
    assert_lines_inside(&l, &path);
    // The top of an ellipse is too narrow for a line at its very edge: the first line starts lower.
    assert!(l.lines[0].baseline - l.lines[0].ascent > 1.0, "{:?}", l.lines[0]);
    // Lines go down the shape in text order.
    for w in l.lines.windows(2) {
        assert!(w[1].baseline >= w[0].baseline && w[1].range.start >= w[0].range.end, "{w:?}");
    }
    // Middle lines are wider than the first (the ellipse is widest in the middle).
    let width = |i: usize| l.lines[i].x1 - l.lines[i].x0;
    assert!(width(l.lines.len() / 2) > width(0), "{l:?}");
}

#[test]
fn area_overflow_is_hidden() {
    let mut e = TextEngine::new();
    let mut t = point(&BUBBLE_TEXT.repeat(10), 14.0);
    let path = area_ellipse(0.0, 0.0, 200.0, 80.0);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert!(!l.lines.is_empty());
    assert!(l.lines.last().unwrap().range.end < t.text.len(), "the rest is hidden");
    assert_lines_inside(&l, &path);
}

/// A long word that reaches the narrow bottom of a full bubble is hidden with the rest, not
/// drawn past the outline: the wide middle rows would hold it, so the shape just ran out.
#[test]
fn area_overflow_at_the_narrow_bottom_is_hidden() {
    let mut e = TextEngine::new();
    let words = "Unfortunately the misunderstanding between representatives continued indefinitely. ";
    for (w, h, size) in [(260.0, 160.0, 12.0), (180.0, 140.0, 14.0), (150.0, 220.0, 12.0)] {
        let mut t = point(&words.repeat(8), size);
        let path = area_ellipse(0.0, 0.0, w, h);
        t.shape = TextShape::Area { path: path.clone() };
        let l = e.layout(&t, 72.0);
        assert!(!l.lines.is_empty());
        assert!(l.lines.last().unwrap().range.end < t.text.len(), "the rest is hidden");
        assert_lines_inside(&l, &path);
    }
}

/// The same in a later paragraph: its own rows start below the wide top of the shape, but the
/// shape would still hold the word there, so it is hidden rather than drawn past the outline.
#[test]
fn area_overflow_in_a_later_paragraph_is_hidden() {
    let mut e = TextEngine::new();
    // A funnel: 300 px wide at the top, a point at the bottom.
    let path = area_poly(&[(0.0, 0.0), (300.0, 0.0), (150.0, 300.0)]);
    for n in (10..120).step_by(5) {
        let text = format!("{}\nmisunderstanding and more", "cat ".repeat(n));
        let mut t = point(&text, 12.0);
        t.shape = TextShape::Area { path: path.clone() };
        let l = e.layout(&t, 72.0);
        assert_lines_inside(&l, &path);
    }
}

#[test]
fn area_lines_center_in_their_span() {
    let mut e = TextEngine::new();
    let mut t = point(BUBBLE_TEXT, 12.0);
    t.paragraphs = vec![ParagraphRun { len: t.text.len(), style: ParagraphStyle { align: TextAlign::Center, ..Default::default() } }];
    // A diamond: every row's span is centred on x = 100.
    t.shape = TextShape::Area { path: area_poly(&[(100.0, 0.0), (200.0, 100.0), (100.0, 200.0), (0.0, 100.0)]) };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 3);
    for line in &l.lines {
        assert!(((line.x0 + line.x1) / 2.0 - 100.0).abs() < 1.5, "{line:?}");
    }
}

/// Horizontal scale applies after shaping, so area lines break at the span width divided by it:
/// widened text stays inside the shape and centred lines stay centred (#5565).
#[test]
fn horizontally_scaled_area_text_stays_inside_its_spans() {
    let mut e = TextEngine::new();
    let style = CharStyle { font_family: "Inter".into(), size_pt: 12.0, horizontal_scale: 1.5, ..Default::default() };
    let mut t = styled(BUBBLE_TEXT, style);
    let path = area_ellipse(0.0, 0.0, 240.0, 200.0);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 3, "{:?}", l.lines);
    assert_lines_inside(&l, &path);
    t.paragraphs = vec![ParagraphRun { len: t.text.len(), style: ParagraphStyle { align: TextAlign::Center, ..Default::default() } }];
    t.shape = TextShape::Area { path: area_poly(&[(100.0, 0.0), (200.0, 100.0), (100.0, 200.0), (0.0, 100.0)]) };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 2, "{:?}", l.lines);
    for line in &l.lines {
        assert!(((line.x0 + line.x1) / 2.0 - 100.0).abs() < 1.5, "{line:?}");
    }
}

#[test]
fn area_rows_split_around_a_hole() {
    use photocraft_doc::vector::{PathOp, Subpath};
    let mut e = TextEngine::new();
    let mut t = point(&BUBBLE_TEXT.repeat(6), 12.0);
    let path = photocraft_doc::vector::Path::new(vec![
        Subpath::polygon(&[(0.0, 0.0), (300.0, 0.0), (300.0, 300.0), (0.0, 300.0)]),
        Subpath::polygon(&[(120.0, 100.0), (180.0, 100.0), (180.0, 200.0), (120.0, 200.0)]).with_op(PathOp::Subtract),
    ]);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert_lines_inside(&l, &path);
    // Some baseline carries two lines: one left of the hole, one right of it, left first.
    let w = l.lines.windows(2).find(|w| (w[0].baseline - w[1].baseline).abs() < 1e-3).expect("a row split around the hole");
    let (left, right) = (&w[0], &w[1]);
    assert!(left.x1 <= 120.5 && right.x0 >= 179.5, "{left:?} {right:?}");
}

#[test]
fn vertical_area_text_stays_inside() {
    use photocraft_doc::text::Orientation;
    let mut e = TextEngine::new();
    let mut t = point(BUBBLE_TEXT, 12.0);
    t.orientation = Orientation::Vertical;
    t.shape = TextShape::Area { path: area_poly(&[(0.0, 0.0), (120.0, 0.0), (120.0, 200.0), (0.0, 200.0)]) };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 2, "several columns");
    for g in &l.glyphs {
        assert!(g.x > -1.0 && g.x < 121.0 && g.y > -1.0 && g.y < 201.0, "{g:?}");
    }
}

#[test]
fn area_without_room_lays_out_nothing_and_a_bad_path_lays_out_as_point_text() {
    let mut e = TextEngine::new();
    let mut t = point("Hello", 40.0);
    // 10 px tall: no 40 pt line fits.
    t.shape = TextShape::Area { path: area_poly(&[(0.0, 0.0), (300.0, 0.0), (300.0, 10.0), (0.0, 10.0)]) };
    assert!(e.layout(&t, 72.0).lines.is_empty());
    // An open path encloses nothing (only reachable from a hostile file): point text, no panic.
    t.shape = TextShape::Area { path: photocraft_doc::vector::Path::new(vec![photocraft_doc::vector::Subpath::polyline(&[(0.0, 0.0), (9.0, 9.0)])]) };
    let point_layout = e.layout(&point("Hello", 40.0), 72.0);
    assert_eq!(e.layout(&t, 72.0).lines.len(), point_layout.lines.len());
}

#[test]
fn area_word_wider_than_every_span_overflows_instead_of_hiding_the_text() {
    use photocraft_doc::vector::Subpath;
    let mut e = TextEngine::new();
    // Two 40 px columns 120 px apart: their bounding box is 200 px wide, but no span is wider
    // than 40 px, so no row can ever hold the long word.
    let mut t = point("Wonderfulness is a long word", 12.0);
    let path = photocraft_doc::vector::Path::new(vec![
        Subpath::polygon(&[(0.0, 0.0), (40.0, 0.0), (40.0, 200.0), (0.0, 200.0)]),
        Subpath::polygon(&[(160.0, 0.0), (200.0, 0.0), (200.0, 200.0), (160.0, 200.0)]),
    ]);
    t.shape = TextShape::Area { path };
    let l = e.layout(&t, 72.0);
    let first = l.lines.first().expect("the text is shown");
    // The word overflows its 40 px span on the first row (box text would break it, #6694).
    assert!(first.x1 - first.x0 > 40.0 && first.x1 - first.x0 < 200.0, "{first:?}");
    assert!(first.x0 >= -0.5, "{first:?}");
    // Nothing is hidden.
    assert_eq!(l.lines.last().map(|line| line.range.end), Some(t.text.len()), "{:?}", l.lines);
}

#[test]
fn single_size_area_paragraph_breaks_in_one_pass() {
    let mut e = TextEngine::new();
    let mut t = point(BUBBLE_TEXT, 12.0);
    t.shape = TextShape::Area { path: area_poly(&[(0.0, 0.0), (300.0, 0.0), (300.0, 300.0), (0.0, 300.0)]) };
    crate::layout::AREA_PASSES.with(|c| c.set(0));
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 2);
    // Rows are planned with the paragraph's real metrics: no re-plan and no skipped spans.
    assert_eq!(crate::layout::AREA_PASSES.with(|c| c.get()), 1);
}

#[test]
fn area_word_skips_a_narrow_span_for_a_wider_one_on_the_same_row() {
    let mut e = TextEngine::new();
    let mut t = point("Wonderful things happen in speech bubbles every single day.", 12.0);
    // A U: a 24 px left arm and a wide right arm above y = 150, joined below it.
    let path = area_poly(&[(0.0, 0.0), (24.0, 0.0), (24.0, 150.0), (80.0, 150.0), (80.0, 0.0), (300.0, 0.0), (300.0, 200.0), (0.0, 200.0)]);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert_lines_inside(&l, &path);
    let first = l.lines.first().expect("the text is shown");
    // "Wonderful" is wider than the left arm: it starts the text in the right arm, on the first
    // row, and nothing is put in the left arm's span on that row.
    assert_eq!(first.range.start, 0);
    assert!(first.x0 >= 79.5, "{first:?}");
    assert!(first.baseline < 30.0, "first row: {first:?}");
    assert_eq!(l.lines.iter().filter(|line| (line.baseline - first.baseline).abs() < 1e-3).count(), 1, "{:?}", l.lines);
    assert_eq!(l.lines.last().map(|line| line.range.end), Some(t.text.len()), "nothing hidden");
}

#[test]
fn area_stacks_paragraphs_with_leading_and_space_before() {
    let mut e = TextEngine::new();
    let text = "First paragraph of the bubble text.\nSecond paragraph goes right after it.";
    let mut t = point(text, 12.0);
    let style = ParagraphStyle { space_before_pt: 6.0, ..Default::default() };
    let leading = style.auto_leading * 12.0;
    t.paragraphs = vec![ParagraphRun { len: text.len(), style }];
    let path = area_poly(&[(0.0, 0.0), (120.0, 0.0), (120.0, 300.0), (0.0, 300.0)]);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert_lines_inside(&l, &path);
    let (p0, p1): (Vec<_>, Vec<_>) = l.lines.iter().partition(|line| line.paragraph == 0);
    assert!(p0.len() >= 2 && p1.len() >= 2, "both paragraphs wrap: {:?}", l.lines);
    assert!(p1.iter().all(|line| line.paragraph == 1));
    // The second paragraph starts right after the break, one leading plus space before lower.
    let second = text.find('\n').unwrap() + 1;
    assert_eq!(p1[0].range.start, second);
    let gap = p1[0].baseline - p0.last().unwrap().baseline;
    assert!((gap - (leading + 6.0)).abs() < 1.0, "gap {gap}, want {}", leading + 6.0);
    // Lines within a paragraph are one leading apart.
    for w in p0.windows(2) {
        assert!((w[1].baseline - w[0].baseline - leading).abs() < 1.0, "{w:?}");
    }
    assert_eq!(l.lines.last().map(|line| line.range.end), Some(text.len()));
}

#[test]
fn area_justify_fills_each_span_but_the_last_line() {
    let mut e = TextEngine::new();
    let mut t = point(&BUBBLE_TEXT.repeat(2), 12.0);
    t.paragraphs = vec![ParagraphRun { len: t.text.len(), style: ParagraphStyle { align: TextAlign::JustifyLeft, ..Default::default() } }];
    let path = area_ellipse(0.0, 0.0, 260.0, 160.0);
    t.shape = TextShape::Area { path: path.clone() };
    let l = e.layout(&t, 72.0);
    assert!(l.lines.len() >= 4, "{}", l.lines.len());
    assert_lines_inside(&l, &path);
    let a = crate::area::AreaShape::new(&path, false).unwrap();
    let span_of = |line: &crate::LineInfo| {
        a.spans(line.baseline - line.ascent, line.baseline + line.descent, 0.0)
            .into_iter()
            .find(|&(s0, s1)| line.x0 >= s0 - 0.5 && line.x1 <= s1 + 0.5)
            .unwrap()
    };
    let (last, rest) = l.lines.split_last().unwrap();
    for line in rest {
        // Justified: the glyphs run from one edge of the line's span to the other.
        let (s0, s1) = span_of(line);
        let ink = l.glyphs.iter().filter(|g| (g.y - line.baseline).abs() < 1e-3).map(|g| g.x).fold(f32::MIN, f32::max);
        assert!((line.x0 - s0).abs() < 1.0, "{line:?} in {s0}..{s1}");
        assert!(ink > s1 - 12.0, "last glyph at {ink}, span ends {s1}: {line:?}");
    }
    // The last line is set flush left, not stretched.
    let (s0, s1) = span_of(last);
    assert!((last.x0 - s0).abs() < 1.0 && last.x1 < s1 - 12.0, "{last:?} in {s0}..{s1}");
}

/// #8602: each colour is rasterised only over its own glyphs instead of the whole text, and the
/// pixels match a full-size pass per colour (plain, faux bold, underlined, rotated and warped
/// text; RGB and CMYK), up to float rounding in the coverage sums.
#[test]
fn per_colour_passes_match_full_size_passes() {
    use photocraft_doc::text::TextWarp;
    let mut e = TextEngine::new();
    let text = "Many coloured runs of text, one colour a letter, across two lines\nof a point text layer";
    let colours = [Color::rgb(0.9, 0.1, 0.1), Color::rgb(0.1, 0.7, 0.2), Color::rgb(0.1, 0.2, 0.9), Color::rgb(0.6, 0.6, 0.1)];
    let runs = |bold: bool| {
        text.char_indices()
            .map(|(i, ch)| {
                let colour = colours[i % colours.len()];
                let style = CharStyle { size_pt: 28.0, color: colour, faux_bold: bold && i % 3 == 0, underline: i % 5 == 0, ..Default::default() };
                TextRun { len: ch.len_utf8(), style }
            })
            .collect::<Vec<_>>()
    };
    let cases = [
        TextLayer { text: text.into(), runs: runs(false), transform: Affine::translate(10.0, 40.0), ..Default::default() },
        TextLayer { text: text.into(), runs: runs(true), transform: Affine::rotate(0.3).then(&Affine::translate(30.0, 90.0)), ..Default::default() },
        TextLayer {
            text: text.into(),
            runs: runs(true),
            transform: Affine::translate(10.0, 60.0),
            warp: Some(TextWarp { style: "warpArc".into(), value: 40.0, horizontal_distortion: 0.0, vertical_distortion: 0.0, horizontal: true }),
            ..Default::default()
        },
    ];
    for (k, t) in cases.iter().enumerate() {
        let l = e.layout(t, 72.0);
        let warp = crate::render::layout_deform(&l, t);
        for format in [PixelFormat::RGBA8, PixelFormat::CMYKA8] {
            let fast = crate::render::rasterize_passes(&l, &t.transform, format, t.antialias, warp.as_ref(), true);
            let full = crate::render::rasterize_passes(&l, &t.transform, format, t.antialias, warp.as_ref(), false);
            assert_eq!(fast.rect, full.rect, "case {k}");
            let (a, b) = (fast.surface.read_region(fast.rect), full.surface.read_region(full.rect));
            assert!(!a.is_empty());
            // Compare what shows: colour weighted by alpha (a fully transparent pixel's colour is moot).
            let ch = format.channels();
            let shown = |px: &[f32]| {
                px.chunks_exact(ch).flat_map(|p| p[..ch - 1].iter().map(|c| c * p[ch - 1]).chain([p[ch - 1]]).collect::<Vec<_>>()).collect::<Vec<_>>()
            };
            let worst = shown(&a).iter().zip(&shown(&b)).map(|(x, y)| (x - y).abs()).fold(0.0f32, f32::max);
            assert!(worst <= 1.0 / 255.0, "case {k} {format:?}: largest difference {worst}");
        }
    }
}

/// A legacy (Photoshop-era) `Txt2` block shaped like a real one (psd-tools' `text.psd`): the
/// fonts in `DocumentResources /FontSet /Resources`, and each object's `Model /StyleRun` runs
/// holding their style under `RunData /StyleSheet /Features` (named keys) beside `Length`.
fn styled_era_txt2(text: &str, font: &str, size: f64, auto_kern: i64) -> Vec<u8> {
    use crate::engine_data::Value as E;
    let font_entry = |name: &str| {
        E::Dict(vec![(
            "Resource".into(),
            E::Dict(vec![
                ("StreamTag".into(), E::Name("CoolTypeFont".into())),
                ("Identifier".into(), E::Dict(vec![("Name".into(), E::String(name.into())), ("Type".into(), E::Int(1))])),
            ]),
        )])
    };
    let features = E::Dict(vec![
        ("Font".into(), E::Int(0)),
        ("FontSize".into(), E::Real(size)),
        ("FauxBold".into(), E::Bool(false)),
        ("FauxItalic".into(), E::Bool(false)),
        ("AutoLeading".into(), E::Bool(true)),
        ("Leading".into(), E::Real(0.01)),
        ("HorizontalScale".into(), E::Real(1.0)),
        ("VerticalScale".into(), E::Real(1.0)),
        ("Tracking".into(), E::Int(0)),
        ("AutoKern".into(), E::Int(auto_kern)),
        ("BaselineShift".into(), E::Real(0.0)),
        ("FontCaps".into(), E::Int(0)),
        ("FontBaseline".into(), E::Int(0)),
        ("UnderlinePosition".into(), E::Int(0)),
        ("StrikethroughPosition".into(), E::Int(0)),
        ("Ligatures".into(), E::Bool(true)),
        ("DiscretionaryLigatures".into(), E::Bool(false)),
        ("ContextualLigatures".into(), E::Bool(true)),
        ("StylisticSets".into(), E::Int(0)),
        (
            "FillColor".into(),
            E::Dict(vec![
                ("StreamTag".into(), E::Name("SimplePaint".into())),
                (
                    "Color".into(),
                    E::Dict(vec![("Type".into(), E::Int(1)), ("Values".into(), E::Array(vec![E::Real(1.0), E::Real(0.0), E::Real(0.0), E::Real(0.0)]))]),
                ),
            ]),
        ),
    ]);
    let total = format!("{text}\r").encode_utf16().count() as i64;
    let run = |len: i64, data: E| E::Dict(vec![("RunData".into(), data), ("Length".into(), E::Int(len))]);
    let placeholder = || E::Dict(vec![("0".into(), E::String(String::new()))]);
    let style_data = E::Dict(vec![(
        "StyleSheet".into(),
        E::Dict(vec![("Name".into(), E::String(String::new())), ("Parent".into(), E::Int(0)), ("Features".into(), features)]),
    )]);
    let entry = E::Dict(vec![
        (
            "Model".into(),
            E::Dict(vec![
                ("Text".into(), E::String(format!("{text}\r"))),
                ("ParagraphRun".into(), E::Dict(vec![("RunArray".into(), E::Array(vec![run(total, placeholder())]))])),
                ("StyleRun".into(), E::Dict(vec![("RunArray".into(), E::Array(vec![run(total, style_data)]))])),
                ("KernRun".into(), E::Dict(vec![("RunArray".into(), E::Array(vec![run(total, placeholder())]))])),
            ]),
        ),
        ("View".into(), E::Dict(vec![("0".into(), E::Array(vec![E::Dict(vec![("0".into(), E::Int(0))])]))])),
    ]);
    crate::engine_data::write_bare(&[
        ("DocumentResources".into(), E::Dict(vec![("FontSet".into(), E::Dict(vec![("Resources".into(), E::Array(vec![font_entry(font)]))]))])),
        ("DocumentObjects".into(), E::Dict(vec![("TextObjects".into(), E::Array(vec![entry]))])),
    ])
}

/// The length and `Features` of each style run of the first legacy object.
fn era_runs(block: &crate::engine_data::Value) -> Vec<(i64, crate::engine_data::Value)> {
    use crate::engine_data::Value as E;
    block
        .path(&["DocumentObjects", "TextObjects"])
        .and_then(E::as_array)
        .and_then(<[E]>::first)
        .and_then(|e| e.path(&["Model", "StyleRun", "RunArray"]))
        .and_then(E::as_array)
        .map(|rs| {
            rs.iter()
                .map(|r| (r.get("Length").and_then(E::as_i64).unwrap_or(-1), r.path(&["RunData", "StyleSheet", "Features"]).cloned().unwrap_or(E::Int(0))))
                .collect()
        })
        .unwrap_or_default()
}

/// Review of #8888 (CodeRabbit, psd.rs): a style-only edit (no text change) restyles the older
/// Photoshop's copy too, which Photoshop re-renders from. Its font list gains the new font, the
/// run keeps every key Photoshop wrote, and the lengths still cover the text.
#[test]
fn a_style_only_edit_restyles_the_photoshop_era_objects() {
    use crate::engine_data::Value as E;
    let prev = styled_era_txt2("Line 1", "ArialMT", 13.0, 1);
    let style = CharStyle {
        postscript_name: Some("Courier".into()),
        size_pt: 20.0,
        faux_bold: true,
        color: Color::rgb(0.0, 0.5, 1.0),
        tracking: 25.0,
        ..Default::default()
    };
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &styled("Line 1", style))], Some(&prev))).unwrap();
    let runs = era_runs(&out);
    assert_eq!(runs.len(), 1);
    let (length, f) = &runs[0];
    assert_eq!(*length, 7, "the run covers the text and its trailing return");
    assert_eq!(f.get("FontSize").and_then(E::as_f64), Some(20.0));
    assert_eq!(f.get("FauxBold").and_then(E::as_bool), Some(true));
    assert_eq!(f.get("Tracking").and_then(E::as_i64), Some(25));
    assert_eq!(f.get("Leading").and_then(E::as_f64), Some(0.01), "an automatic leading keeps Photoshop's own value");
    assert_eq!(f.path(&["FillColor", "Color", "Type"]).and_then(E::as_i64), Some(1));
    assert_eq!(f.path(&["FillColor", "Color", "Values"]).and_then(E::as_array).map(<[E]>::len), Some(4));
    assert_eq!(f.path(&["FillColor", "StreamTag"]).and_then(E::as_str), Some("SimplePaint"), "a key the file held is kept");
    // The font went into the block's list and the run names it.
    let fonts = out.path(&["DocumentResources", "FontSet", "Resources"]).and_then(E::as_array).expect("the font list");
    let index = f.get("Font").and_then(E::as_i64).and_then(|i| usize::try_from(i).ok()).expect("the font index");
    let name = |i: usize| fonts.get(i).and_then(|r| r.path(&["Resource", "Identifier", "Name"])).and_then(E::as_str);
    assert_eq!(name(index), Some("Courier"));
    assert_eq!(name(0), Some("ArialMT"), "the file's font stays first");
    // The text did not change.
    let text =
        out.path(&["DocumentObjects", "TextObjects"]).and_then(E::as_array).and_then(<[E]>::first).and_then(|e| e.path(&["Model", "Text"])).and_then(E::as_str);
    assert_eq!(text, Some("Line 1\r"));
}

/// A layer whose style already agrees with the file's run leaves the legacy objects as they are.
#[test]
fn an_unedited_style_leaves_the_photoshop_era_objects_alone() {
    let prev = styled_era_txt2("Line 1", "ArialMT", 13.0, 1);
    let same = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 13.0, ..Default::default() };
    let out = crate::psd::build_txt2(&[(0, &styled("Line 1", same))], Some(&prev));
    assert_eq!(era_runs(&crate::psd::parse_txt2(&prev).unwrap()), era_runs(&crate::psd::parse_txt2(&out).unwrap()));
}

/// Both object lists, as CodeRabbit asked: the numbered object and the older copy are restyled by
/// the same style-only edit.
#[test]
fn a_style_only_edit_restyles_both_object_lists() {
    use crate::engine_data::Value as E;
    let mut prev = photoshop_txt2(&[(4, 1)]);
    prev.extend_from_slice(&styled_era_txt2("AVA", "ArialMT", 13.0, 1));
    let style = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 31.0, faux_italic: true, ..Default::default() };
    let out = crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &styled("AVA", style))], Some(&prev))).unwrap();
    let legacy = era_runs(&out);
    let first = legacy.first().map(|(l, f)| (*l, f.get("FontSize").and_then(E::as_f64), f.get("FauxItalic").and_then(E::as_bool)));
    assert_eq!(first, Some((4, Some(31.0), Some(true))));
    let numbered = out
        .path(&["1", "1"])
        .and_then(E::as_array)
        .and_then(<[E]>::first)
        .and_then(|o| o.path(&["0", "6", "0"]))
        .and_then(E::as_array)
        .and_then(<[E]>::first)
        .and_then(|r| r.path(&["0", "0", "6"]));
    assert_eq!(numbered.and_then(|s| s.get("1")).and_then(E::as_f64), Some(31.0), "the numbered object is restyled too");
}

/// Two character runs give two style runs in the legacy copy, with the lengths of the runs.
#[test]
fn a_two_run_layer_gives_the_photoshop_era_copy_two_style_runs() {
    use crate::engine_data::Value as E;
    let prev = styled_era_txt2("Hello", "ArialMT", 13.0, 1);
    let small = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 10.0, ..Default::default() };
    let big = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 40.0, ..Default::default() };
    let t = runs_of("Hello", &[(2, small), (3, big)]);
    let runs = era_runs(&crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap());
    let seen: Vec<(i64, Option<f64>)> = runs.iter().map(|(l, f)| (*l, f.get("FontSize").and_then(E::as_f64))).collect();
    assert_eq!(seen, vec![(2, Some(10.0)), (4, Some(40.0))], "the last run takes the trailing return");
}

/// Review of #8888: every key the legacy restyle writes is written per run, so a multi-run edit
/// does not copy the first run's baseline shift, case, underline or strikethrough to the others.
#[test]
fn each_photoshop_era_style_run_gets_its_own_values() {
    use crate::engine_data::Value as E;
    use photocraft_doc::text::{Caps, FontBaseline};
    let prev = styled_era_txt2("Hello", "ArialMT", 13.0, 1);
    let base = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 13.0, ..Default::default() };
    let decorated = CharStyle { baseline_shift_pt: 3.0, caps: Caps::SmallCaps, baseline: FontBaseline::Superscript, underline: true, ..base.clone() };
    let struck = CharStyle { strikethrough: true, caps: Caps::AllCaps, ligatures: false, discretionary_ligatures: true, ..base.clone() };
    let t = runs_of("Hello", &[(2, decorated), (2, base.clone()), (1, struck)]);
    let runs = era_runs(&crate::psd::parse_txt2(&crate::psd::build_txt2(&[(0, &t)], Some(&prev))).unwrap());
    let key = |i: usize, k: &str| runs.get(i).and_then(|(_, f)| f.get(k)).cloned();
    assert_eq!(runs.iter().map(|r| r.0).collect::<Vec<_>>(), vec![2, 2, 2]);
    assert_eq!(key(0, "BaselineShift").and_then(|v| v.as_f64()), Some(3.0));
    assert_eq!(key(1, "BaselineShift").and_then(|v| v.as_f64()), Some(0.0), "the second run is not the first");
    assert_eq!([0, 1, 2].map(|i| key(i, "FontCaps").and_then(|v| v.as_i64())), [Some(1), Some(0), Some(2)]);
    assert_eq!([0, 1, 2].map(|i| key(i, "FontBaseline").and_then(|v| v.as_i64())), [Some(1), Some(0), Some(0)]);
    assert_eq!([0, 1, 2].map(|i| key(i, "UnderlinePosition").and_then(|v| v.as_i64()).map(|v| v != 0)), [Some(true), Some(false), Some(false)]);
    assert_eq!([0, 1, 2].map(|i| key(i, "StrikethroughPosition").and_then(|v| v.as_i64()).map(|v| v != 0)), [Some(false), Some(false), Some(true)]);
    assert_eq!([0, 1, 2].map(|i| key(i, "Ligatures").and_then(|v| v.as_bool())), [Some(true), Some(true), Some(false)]);
    assert_eq!([0, 1, 2].map(|i| key(i, "DiscretionaryLigatures").and_then(|v| v.as_bool())), [Some(false), Some(false), Some(true)]);
    let _ = E::Int(0);
}

/// Each of those keys alone is enough to restyle the legacy copy (an edit of only that key), and
/// a layer that agrees on all of them leaves the block's bytes alone.
#[test]
fn every_legacy_style_key_is_compared() {
    use photocraft_doc::text::{Caps, FontBaseline, Kerning};
    let prev = styled_era_txt2("Hello", "ArialMT", 13.0, 1);
    let base = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 13.0, ..Default::default() };
    let unedited = crate::psd::build_txt2(&[(0, &styled("Hello", base.clone()))], Some(&prev));
    assert!(
        era_runs(&crate::psd::parse_txt2(&unedited).unwrap()) == era_runs(&crate::psd::parse_txt2(&prev).unwrap()),
        "an agreeing layer leaves the legacy copy as it is"
    );
    let edits = [
        CharStyle { baseline_shift_pt: 2.0, ..base.clone() },
        CharStyle { caps: Caps::AllCaps, ..base.clone() },
        CharStyle { baseline: FontBaseline::Subscript, ..base.clone() },
        CharStyle { underline: true, ..base.clone() },
        CharStyle { strikethrough: true, ..base.clone() },
        CharStyle { ligatures: false, ..base.clone() },
        CharStyle { discretionary_ligatures: true, ..base.clone() },
        CharStyle { kerning: Kerning::Optical, ..base.clone() },
    ];
    for (i, edit) in edits.into_iter().enumerate() {
        let out = crate::psd::build_txt2(&[(0, &styled("Hello", edit))], Some(&prev));
        assert!(era_runs(&crate::psd::parse_txt2(&out).unwrap()) != era_runs(&crate::psd::parse_txt2(&prev).unwrap()), "edit {i} restyles the legacy copy");
    }
}

/// Review of #8888: the legacy `AutoKern` mode is read on import, as `/11` is for the numbered
/// objects, so the layer a legacy file opens as agrees with its legacy copy.
#[test]
fn legacy_auto_kern_is_read_on_import() {
    use photocraft_doc::text::Kerning;
    let t = styled("AVA", CharStyle::default());
    let tysh = with_text_index(&crate::psd::build_tysh(&t, 72.0, None), 0);
    for (mode, want) in [(0, Kerning::Off), (1, Kerning::Metrics), (2, Kerning::Optical)] {
        let txt2 = crate::psd::parse_txt2(&styled_era_txt2("AVA", "ArialMT", 13.0, mode)).unwrap();
        let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
        crate::psd::apply_txt2(&mut back, &tysh, &txt2);
        assert!(
            back.char_runs().iter().all(|r| r.style.kerning == want),
            "AutoKern {mode}: {:?}",
            back.char_runs().iter().map(|r| r.style.kerning).collect::<Vec<_>>()
        );
    }
    // Other text, or another object, changes nothing.
    let txt2 = crate::psd::parse_txt2(&styled_era_txt2("AVX", "ArialMT", 13.0, 2)).unwrap();
    let mut back = crate::psd::text_layer_from_tysh(&tysh, 72.0).unwrap();
    crate::psd::apply_txt2(&mut back, &tysh, &txt2);
    assert!(back.char_runs().iter().all(|r| r.style.kerning == Kerning::Metrics));
}

/// Review of the batch (FredApps, with #9104): a style-only save rewrites `Txt2`, and the raw
/// (non-BOM) strings Photoshop wrote in it, `/2 (0100)` and `/3 (01110)` under `/98`, must come
/// back as the same bytes: re-encoded as `FE FF` UTF-16 they make Photoshop refuse the file.
#[test]
fn a_style_only_save_keeps_the_raw_strings_of_the_file() {
    let mut prev = photoshop_txt2(&[(4, 1)]);
    let version = b"/98 << /0 14 >>";
    let at = prev.windows(version.len()).position(|w| w == version).expect("the version key");
    prev.splice(at..at + version.len(), b"/98 << /0 14 /2 (0100) /3 (01110) >>".iter().copied());
    // A size the file's runs do not have: the block is rewritten.
    let style = CharStyle { size_pt: 31.0, faux_bold: false, ..Default::default() };
    let out = crate::psd::build_txt2(&[(0, &styled("AVA", style))], Some(&prev));
    assert_ne!(out, prev, "the style edit rewrites the block");
    let has = |needle: &[u8]| out.windows(needle.len()).any(|w| w == needle);
    assert!(has(b"(0100)") && has(b"(01110)"), "the raw strings come back as the same bytes: {:?}", String::from_utf8_lossy(&out));
    assert!(!has(b"(\xfe\xff\x000\x001\x000\x000)"), "and not as UTF-16");
}

/// The same for the older Photoshop's objects: restyling the legacy copy leaves a raw string
/// elsewhere in the block as the file wrote it.
#[test]
fn restyling_the_photoshop_era_objects_keeps_the_raw_strings_of_the_file() {
    use crate::engine_data::Value as E;
    let era = crate::psd::parse_txt2(&styled_era_txt2("Line 1", "ArialMT", 13.0, 1)).unwrap();
    let E::Dict(mut items) = era else { panic!("a dictionary") };
    items.push(("98".into(), E::Dict(vec![("0".into(), E::Int(14)), ("2".into(), E::RawString("0100".into()))])));
    let prev = crate::engine_data::write_bare(&items);
    let style = CharStyle { postscript_name: Some("ArialMT".into()), size_pt: 24.0, ..Default::default() };
    let out = crate::psd::build_txt2(&[(0, &styled("Line 1", style))], Some(&prev));
    assert!(out.windows(6).any(|w| w == b"(0100)"), "{:?}", String::from_utf8_lossy(&out));
    let runs = era_runs(&crate::psd::parse_txt2(&out).unwrap());
    assert_eq!(runs.first().and_then(|(_, f)| f.get("FontSize")).and_then(E::as_f64), Some(24.0), "and the legacy copy was restyled");
}

#[test]
fn glyph_outlines_preserves_style_indices() {
    let mut e = TextEngine::new();
    let t = TextLayer {
        text: "AB".into(),
        transform: Affine::translate(10.0, 30.0),
        runs: vec![
            photocraft_doc::text::TextRun { len: 1, style: CharStyle { color: Color::rgb(1.0, 0.0, 0.0), ..Default::default() } },
            photocraft_doc::text::TextRun { len: 1, style: CharStyle { color: Color::rgb(0.0, 1.0, 0.0), ..Default::default() } },
        ],
        ..Default::default()
    };
    let layout = e.layout(&t, 72.0);
    let glyphs = crate::render::glyph_outlines(&layout, &t.transform, None);
    assert!(glyphs.len() >= 2);
    assert_eq!(glyphs[0].style, 0);
    assert_eq!(glyphs[1].style, 1);
}

/// Colour passes are grouped in one walk of the glyphs: with a colour per letter, every placed
/// glyph lands in exactly one pass and each pass holds only its own glyphs.
#[test]
fn colour_passes_hold_each_glyph_once() {
    let mut e = TextEngine::new();
    let text = "abcdeghjkm".repeat(200);
    let runs = text
        .char_indices()
        .map(|(i, ch)| TextRun { len: ch.len_utf8(), style: CharStyle { size_pt: 12.0, color: Color::rgb(i as f32 / 2000.0, 0.5, 0.5), ..Default::default() } })
        .collect();
    let t = TextLayer { text, runs, ..Default::default() };
    let l = e.layout(&t, 72.0);
    let passes = crate::render::visible_color_passes(&l, None);
    assert!(passes.len() > 1000, "{} passes", passes.len());
    let mut seen: Vec<usize> = passes.iter().flat_map(|(_, _, p)| p.glyphs.iter().copied()).collect();
    seen.sort_unstable();
    assert_eq!(seen, (0..l.glyphs.len()).collect::<Vec<_>>());
    for (c, _, p) in &passes {
        assert!(p.glyphs.iter().all(|&i| l.styles[l.glyphs[i].style as usize].color == *c));
    }
}