//! Default / concrete implementations of the text3 trait abstractions.

//!

//! This module bridges the generic text3 layout engine and the concrete

//! `FontRef` / `ParsedFont` types.  It provides:

//!

//! - `ParsedFontTrait` implementation for `FontRef`

//! - Font loading via `PathLoader`

//! - The core `shape_text_internal` shaping function

use std::{path::Path, sync::Arc};

use allsorts::{

    gpos,

    gsub::{self, Feature, FeatureInfo, FeatureMask, FeatureMaskExt},

};

use azul_core::geom::LogicalSize;

use azul_css::props::basic::FontRef;

use crate::{

    font::parsed::ParsedFont,

    text3::{

        cache::{

            BidiDirection, BidiLevel, FontManager, FontSelector, FontVariantCaps,

            FontVariantLigatures, FontVariantNumeric, Glyph, GlyphOrientation, GlyphSource,

            LayoutError, LayoutFontMetrics, ParsedFontTrait, Point, ShallowClone, StyleProperties,

            TextCombineUpright, TextDecoration, TextOrientation, VerticalMetrics, WritingMode,

        },

        script::Script,

    },

};

/// Creates a `FontRef` from font bytes by parsing them into a `ParsedFont`.

///

/// This is a bridge function that:

///

/// 1. Parses the bytes into a `ParsedFont`

/// 2. Wraps it in a `FontRef` with proper reference counting

///

/// # Arguments

///

/// - `font_bytes` - The raw font file data

/// - `font_index` - Index of the font in a font collection (0 for single fonts)

/// - `parse_outlines` - Whether to parse glyph outlines (expensive, usually false for layout)

    // Parse the font bytes into ParsedFont

/// A `FontLoader` that parses font data from a byte slice.

///

/// It is designed to be used in conjunction with a mechanism that reads font files

/// from paths into memory. This loader simply handles the parsing aspect.

#[derive(Copy, Debug, Default, Clone)]

pub struct PathLoader;

impl PathLoader {

    /// Creates a new `PathLoader`.

    /// Read a font from disk and parse via the lazy-LocaGlyf path.

    /// Convenience wrapper for callers that have a path but no

    /// `Arc<FontBytes>` yet — uses a heap read (`Owned`) since a

    /// loose path won't go through the fontconfig dedup cache.

    /// Lazy-friendly loader: takes an `Arc<FontBytes>` (typically

    /// from [`rust_fontconfig::FcFontCache::get_font_bytes`]) and

    /// uses the [`ParsedFont::from_bytes_shared`] constructor so

    /// `LocaGlyf::load` is deferred until the first glyph decode.

    ///

    /// This is the only loader on the production path —

    /// `load_fonts_from_disk` calls this via the closure passed

    /// into `FontManager::load_missing_for_chains`. Fonts that

    /// never get rasterized (common — every face of a `.ttc` gets a

    /// `FontId`, but pages only hit a couple of them) skip their

    /// per-face loca+glyf materialisation entirely; with

    /// `FontBytes::Mmapped` the unread pages also never count

    /// toward RSS.

    /// # Errors

    ///

    /// Returns a `LayoutError` if the font cannot be loaded.

}

impl FontManager<FontRef> {

    /// Evict the cached `LocaGlyf` for every face that hasn't had a

    /// `get_or_decode_glyph` call within the last `idle` duration.

    /// Only `LocaGlyfState::Deferred` faces (the production lazy

    /// path) can be evicted — they keep their source `Arc<[u8]>` so

    /// the next glyph access re-parses cheaply. `LocaGlyfState::Loaded`

    /// faces from the eager path stay put.

    ///

    /// Returns the number of faces evicted. Embedders can call this

    /// from a memory-pressure hook or on a timer; servo-shot

    /// exposes it via `--azul-evict-after-each` for measurement.

    #[allow(clippy::cast_possible_truncation)] // bounded layout/render numeric cast

        use crate::font::parsed::ParsedFont;

        };

        // We compare against the same monotonic clock the font's

        // `last_used` is sampled from. `last_used == 0` means

        // "never touched" -> eligible. Otherwise we only evict if

        // `now_nanos - last_used >= idle.as_nanos()`.

            // Untouched faces are eligible immediately. Touched

            // faces need to be `idle` past their last use.

        }

}

// ParsedFontTrait Implementation for FontRef

// Implement ShallowClone for FontRef

impl ShallowClone for FontRef {

        // FontRef::clone increments the reference count

}

// Use crate::font_ref_to_parsed_font instead of a local duplicate

impl ParsedFontTrait for FontRef {

    // +spec:block-formatting-context:21ec9a - bidi direction handled during text shaping for vertical writing modes

        // Delegate to the inner ParsedFont's shape_text, passing self as font_ref

}

/// Extension trait for `FontRef` to provide access to font bytes and metrics

///

/// This trait provides methods that require access to the inner `ParsedFont` data.

pub trait FontRefExt {

    /// Get the original font bytes. Returns an empty slice when the

    /// underlying `ParsedFont` was created without retaining its

    /// source bytes (the default since the lazy-font-loading refactor).

    /// Callers that need the bytes for PDF embedding must construct

    /// the `ParsedFont` via `ParsedFont::with_source_bytes`.

    fn get_bytes(&self) -> &[u8];

    /// Get the full font metrics (PDF-style metrics from HEAD, HHEA, OS/2 tables)

    fn get_full_font_metrics(&self) -> azul_css::props::basic::FontMetrics;

}

impl FontRefExt for FontRef {

        use azul_css::{OptionI16, OptionU16, OptionU32};

        // PdfFontMetrics only has a subset of fields; fill others with defaults

}

// ParsedFont helper method for FontRef

//

// This allows ParsedFont to create glyphs that use FontRef

//

// FontRef is just a C-style Arc wrapper around ParsedFont, so we delegate to

// the common shaping implementation and convert the font reference type.

impl ParsedFont {

    /// Internal helper that shapes text and returns Glyph

    /// Delegates to `shape_text_internal` and converts the font reference.

        // `shape_text_internal` already stamps each glyph with `font_hash`

        // and `font_metrics` derived from `self`, which is the same

        // `ParsedFont` backing `_font_ref`, so no per-glyph rewrite is needed.

            } else {

            };

            // max_x, max_y, min_x, min_y in font units

        } else {

        };

        // U+0640 is the Arabic Tatweel character, used for kashida justification.

        } else {

        };

}

/// Fallback scale factor when `units_per_em` is zero (corrupt/broken font).

const FALLBACK_SCALE: f32 = 0.01;

// Helper Functions

/// Builds a `FeatureMask` with the appropriate OpenType features for a given script.

/// This ensures proper text shaping for complex scripts like Arabic, Devanagari, etc.

///

/// The function includes:

/// - Common features for all scripts (ligatures, contextual alternates, etc.)

/// - Script-specific features (positional forms for Arabic, conjuncts for Indic, etc.)

///

/// This is designed to be stable and explicit - we control exactly which features

/// are enabled rather than relying on allsorts' defaults which may change.

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

    use Script::{Arabic, Devanagari, Bengali, Gujarati, Gurmukhi, Kannada, Malayalam, Oriya, Tamil, Telugu, Myanmar, Khmer, Thai, Hebrew, Hangul, Ethiopic, Latin, Greek, Cyrillic, Georgian, Hiragana, Katakana, Mandarin, Sinhala};

    // Start with common features that apply to most scripts

    // Add script-specific features

        // Arabic and related scripts - require positional forms

        // Indic scripts - require complex conjunct formation and reordering

        Devanagari | Bengali | Gujarati | Gurmukhi | Kannada | Malayalam | Oriya | Tamil

        // Myanmar (Burmese) - has complex reordering

        // Khmer - has complex reordering and stacking

        // Thai - has tone marks and vowel reordering

        // Hebrew - may have contextual forms but less complex than Arabic

        // Hangul (Korean) - has complex syllable composition

        // Ethiopic - has syllabic script with some ligatures

        // Latin, Greek, Cyrillic - standard features are sufficient

        // Georgian - uses standard features

        // CJK scripts (Hiragana, Katakana, Mandarin/Hani)

        // Sinhala - Indic-derived but simpler

    }

/// Maps the layout engine's `Script` enum to an OpenType script tag `u32`.

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

    use Script::{Arabic, Bengali, Cyrillic, Devanagari, Ethiopic, Georgian, Greek, Gujarati, Gurmukhi, Hangul, Hebrew, Hiragana, Kannada, Katakana, Khmer, Latin, Malayalam, Mandarin, Myanmar, Oriya, Sinhala, Tamil, Telugu, Thai};

    // Tags from https://docs.microsoft.com/en-us/typography/opentype/spec/scripttags

        // OpenType does not define a separate Hiragana script tag;

        // both Hiragana and Katakana intentionally use "kana".

    }

/// Parses a CSS-style font-feature-settings string like `"liga"`, `"liga=0"`, or `"ss01"`.

/// Returns an OpenType tag and a value.

    // OpenType feature tags must be 4 characters long.

    // Pad with spaces if necessary

/// A helper to add OpenType features based on CSS `font-variant-*` properties.

    // Helper to add a feature that is simply "on".

    // Note on disabling features: The CSS properties `font-variant-ligatures: none` or

    // `no-common-ligatures` are meant to disable features that may be on by default for a

    // given script. The `allsorts` API for applying custom features is additive and does not

    // currently support disabling default features. This implementation only handles enabling

    // non-default features.

    // Ligatures

    }

    // Caps

    }

    // Numeric

    }

/// Maps the `hyphenation::Language` enum to an OpenType language tag `u32`.

#[cfg(feature = "text_layout_hyphenation")]

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

    use hyphenation::Language::{Afrikaans, Albanian, Armenian, Assamese, Basque, Belarusian, Bengali, Bulgarian, Catalan, Chinese, Coptic, Croatian, Czech, Danish, Dutch, EnglishGB, EnglishUS, Esperanto, Estonian, Ethiopic, Finnish, FinnishScholastic, French, Friulan, Galician, Georgian, German1901, German1996, GermanSwiss, GreekAncient, GreekMono, GreekPoly, Gujarati, Hindi, Hungarian, Icelandic, Indonesian, Interlingua, Irish, Italian, Kannada, Kurmanji, Latin, LatinClassic, LatinLiturgical, Latvian, Lithuanian, Macedonian, Malayalam, Marathi, Mongolian, NorwegianBokmal, NorwegianNynorsk, Occitan, Oriya, Pali, Panjabi, Piedmontese, Polish, Portuguese, Romanian, Romansh, Russian, Sanskrit, SerbianCyrillic, SerbocroatianCyrillic, SerbocroatianLatin, SlavonicChurch, Slovak, Slovenian, Spanish, Swedish, Tamil, Telugu, Thai, Turkish, Turkmen, Ukrainian, Uppersorbian, Welsh};

    // A complete list of language tags can be found at:

    // https://docs.microsoft.com/en-us/typography/opentype/spec/languagetags

    };

/// Internal shaping implementation - the single source of truth for text shaping.

/// Both `FontRef` and `ParsedFont` use this function.

#[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss, clippy::cast_sign_loss)] // bounded layout/render numeric cast

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

    #[cfg(feature = "text_layout_hyphenation")]

    #[cfg(not(feature = "text_layout_hyphenation"))]

    let lang_tag = 0u32;

    // +spec:text-alignment-spacing:4357e6 - non-zero letter-spacing should disable optional ligatures; allsorts API is additive-only so default liga cannot be disabled here

    // +spec:text-alignment-spacing:24d624 - cursive script letter-spacing behavior is advisory (outside CSS scope per spec note)

            } else {

            },

    {

            };

            // NOTE: `liga_component_pos` MUST be left at allsorts' managed default (0)

            // here. It is a GPOS ligature-COMPONENT index, and mark-to-mark /

            // mark-to-ligature attachment (gpos::forall_mark_mark_glyph_pairs,

            // gpos::markligpos) is gated on equality of this field between glyphs.

            // Overloading it with the source byte offset (as an earlier version did)

            // made every glyph carry a distinct value, silently disabling mkmk stacking

            // and mis-selecting ligature-component anchors. Source byte offsets are

            // instead reconstructed after shaping from each glyph's `unicodes` (see the

            // read-back loop below), which also removes the old u16 byte-offset cap that

            // dropped every glyph past byte 65535.

                liga_component_pos: 0,

            });

        }

    }

        // Always start from the script's default feature mask (LIGA, CLIG, CALT,

        // CCMP, LOCL, RLIG + script-specific shaping features) and additively layer

        // any user-supplied features on top. gsub::apply applies the mask AND the

        // custom features, so these are NOT mutually exclusive. The previous code

        // replaced the mask with `empty()` whenever ANY font-feature/font-variant

        // was set, which silently disabled default ligatures/contextual-alternates

        // for Latin-family text (ScriptType::Default only re-adds CCMP|RLIG|LOCL).

        )

        )

    } else {

        // No GPOS table: apply the legacy `kern` table (and fallback mark

        // positioning) directly, so fonts that ship only a legacy `kern` table

        // still kern — matching CoreText/HarfBuzz behavior. Without this,

        // GPOS-less fonts got zero kerning.

    }

    } else {

    };

    // Reconstruct source byte spans by walking the source text in logical order,

    // consuming each glyph's `unicodes`. This replaces the removed liga_component_pos

    // byte-offset overload. A ligature glyph carries ALL of its component chars in

    // `unicodes`, so its span covers every merged component (fixing the ligature

    // logical_byte_len that previously reported only the first component's length).

    // Multiple-substitution duplicates (MULTI_SUBST_DUP) and unicode-less inserted

    // glyphs share the current cursor position and do not advance it.

        } else {

        };

        // Layout uses LINEAR (design-space) advances, like Chrome/Blink and

        // CoreText: with sub-pixel text positioning the rasterizer places

        // each glyph at a fractional origin, and under light hinting the X

        // axis is not grid-fit at all, so integer-quantized hinted advances

        // would only ADD error. Measured: hinted advances inflated runs by

        // ~0.2px per glyph ('l' at 14px: 4.0 hinted vs 3.612 linear), which

        // made every long text run visibly wider than Chrome's (cascade-*

        // reftests). Full grid-fit mode (AZ_HINT_LIGHT=0) keeps the hinted

        // advance so raster and metrics stay mutually consistent; it is

        // rescaled from the integer hinting ppem back to the exact

        // fractional font size to stay on the same basis as the GPOS

        // offsets and kerning below.

        // `hint_light_enabled` lives in glyph_cache, which is `cpurender`-

        // gated; text layout itself is not. Without cpurender there is no

        // rasterizer to stay consistent WITH, so the light (linear-advance)

        // basis — also the default when the module IS present — is the only

        // sensible answer. Reading the same env var here keeps a

        // cpurender-less build honest about AZ_HINT_LIGHT=0 being a

        // raster-side knob it cannot honor.

        #[cfg(feature = "cpurender")]

        #[cfg(not(feature = "cpurender"))]

        let hint_light = true;

        } else {

                )

        };

            } else {

            };

            content_index: 0,

        };

    }

/// Public helper function to shape text for `ParsedFont`, returning Glyph

/// This is used by the `ParsedFontTrait` implementation for `ParsedFont`

/// # Errors

///

/// Returns a `LayoutError` if the text cannot be shaped.

    // Delegate to the single internal implementation

#[cfg(test)]

#[allow(clippy::float_cmp, clippy::cast_lossless, clippy::unreadable_literal)]

mod autotest_generated {

    use std::time::Duration;

    use rust_fontconfig::{FcFontCache, FontBytes, FontId};

    use super::*;

    use crate::text3::script::Language;

    /// Positive control: the built-in `Azul Mock Mono` TrueType face.

    const MOCK_MONO: &[u8] = crate::text3::mock_fonts::MOCK_MONO_TTF;

    /// Every `Script` variant, so the exhaustive mapping tables below can never

    /// silently miss one.

    const ALL_SCRIPTS: [Script; 24] = [

        Script::Arabic,

        Script::Bengali,

        Script::Cyrillic,

        Script::Devanagari,

        Script::Ethiopic,

        Script::Georgian,

        Script::Greek,

        Script::Gujarati,

        Script::Gurmukhi,

        Script::Hangul,

        Script::Hebrew,

        Script::Hiragana,

        Script::Kannada,

        Script::Katakana,

        Script::Khmer,

        Script::Latin,

        Script::Malayalam,

        Script::Mandarin,

        Script::Myanmar,

        Script::Oriya,

        Script::Sinhala,

        Script::Tamil,

        Script::Telugu,

        Script::Thai,

    ];

    /// Eager parse (`LocaGlyfState::Loaded`).

    fn mock() -> ParsedFont {

        let mut warnings = Vec::new();

        ParsedFont::from_bytes(MOCK_MONO, 0, &mut warnings).expect("Azul Mock Mono must parse")

    }

    /// Lazy parse (`LocaGlyfState::Deferred`) — the production path.

    fn mock_deferred() -> ParsedFont {

        let bytes = Arc::new(FontBytes::Owned(Arc::from(MOCK_MONO.to_vec())));

        let mut warnings = Vec::new();

        ParsedFont::from_bytes_shared(bytes, 0, &mut warnings)

            .expect("from_bytes_shared must parse the positive control")

    }

    fn style_at(font_size_px: f32) -> StyleProperties {

        StyleProperties {

            font_size_px,

            ..StyleProperties::default()

        }

    }

    fn shape(font: &ParsedFont, text: &str) -> Result<Vec<Glyph>, LayoutError> {

        shape_text_internal(

            font,

            text,

            Script::Latin,

            Language::EnglishUS,

            BidiDirection::Ltr,

            &style_at(16.0),

        )

    }

    /// Invariants that must hold for *any* shaping result, no matter how hostile

    /// the input: byte spans stay inside the source, land on char boundaries and

    /// never run backwards.

    fn assert_spans_are_sane(glyphs: &[Glyph], text: &str) {

        let mut prev_index = 0usize;

        for g in glyphs {

            assert!(

                g.logical_byte_index <= text.len(),

                "byte index {} escapes the {}-byte source",

                g.logical_byte_index,

                text.len()

            );

            let end = g.logical_byte_index + g.logical_byte_len;

            assert!(

                end <= text.len(),

                "span {}..{end} escapes the {}-byte source",

                g.logical_byte_index,

                text.len()

            );

            assert!(

                text.is_char_boundary(g.logical_byte_index) && text.is_char_boundary(end),

                "span {}..{end} splits a UTF-8 sequence",

                g.logical_byte_index

            );

            assert!(

                g.logical_byte_index >= prev_index,

                "byte cursor ran backwards: {} after {prev_index}",

                g.logical_byte_index

            );

            prev_index = g.logical_byte_index;

            assert_eq!(

                u64::from(g.cluster),

                g.logical_byte_index as u64,

                "cluster must mirror the logical byte index"

            );

        }

    }

    // -----------------------------------------------------------------

    // font_ref_from_bytes (parser)

    // -----------------------------------------------------------------

    #[test]

    fn font_ref_from_bytes_rejects_empty_and_malformed_input() {

        // empty / whitespace-only / invalid-UTF-8 / garbage: None, never a panic

        assert!(font_ref_from_bytes(b"", 0, false).is_none());

        assert!(font_ref_from_bytes(b"   \t\n", 0, false).is_none());

        assert!(font_ref_from_bytes(&[0xFF, 0xFE, 0x00], 0, false).is_none());

        assert!(font_ref_from_bytes(b"not a font at all, just prose", 0, false).is_none());

        // a 4-byte "sfnt-ish" header with nothing behind it

        assert!(font_ref_from_bytes(&[0x00, 0x01, 0x00, 0x00], 0, false).is_none());

        // truncated real font: header only, then a torso

        assert!(font_ref_from_bytes(&MOCK_MONO[..12], 0, false).is_none());

        assert!(font_ref_from_bytes(&MOCK_MONO[..64], 0, false).is_none());

        // leading junk in front of an otherwise valid font must not parse

        let mut prefixed = vec![0xABu8; 32];

        prefixed.extend_from_slice(MOCK_MONO);

        assert!(font_ref_from_bytes(&prefixed, 0, false).is_none());

    }

    #[test]

    fn font_ref_from_bytes_extremely_long_garbage_terminates() {

        // 1 MiB of NULs must be rejected without hanging or allocating wildly

        assert!(font_ref_from_bytes(&vec![0u8; 1_000_000], 0, false).is_none());

        // a "ttcf" collection header followed by a megabyte of noise

        let mut ttc_junk = b"ttcf".to_vec();

        ttc_junk.extend_from_slice(&vec![0xCDu8; 1_000_000]);

        assert!(font_ref_from_bytes(&ttc_junk, 0, false).is_none());

    }

    #[test]

    fn font_ref_from_bytes_valid_minimal_positive_control() {

        let font_ref =

            font_ref_from_bytes(MOCK_MONO, 0, false).expect("Azul Mock Mono must parse into a FontRef");

        assert!(font_ref.num_glyphs() > 0, "a real font has glyphs");

        assert_eq!(font_ref.get_hash(), mock().get_hash());

        assert!(font_ref.has_glyph('a' as u32));

    }

    #[test]

    fn font_ref_from_bytes_ignores_the_parse_outlines_flag() {

        // NOTE: `parse_outlines` is accepted but never forwarded to

        // `ParsedFont::from_bytes` — both settings must therefore produce

        // an identical face. This pins the current (no-op) behaviour.

        let with = font_ref_from_bytes(MOCK_MONO, 0, true).expect("parse with outlines");

        let without = font_ref_from_bytes(MOCK_MONO, 0, false).expect("parse without outlines");

        assert_eq!(with.get_hash(), without.get_hash());

        assert_eq!(with.num_glyphs(), without.num_glyphs());

        assert_eq!(with.get_space_width(), without.get_space_width());

    }

    #[test]

    fn font_ref_from_bytes_extreme_font_index_does_not_panic() {

        // Out-of-range collection indices must resolve to Some/None, never an

        // out-of-bounds index panic.

        for index in [0usize, 1, 255, usize::MAX / 2, usize::MAX] {

            let _ = font_ref_from_bytes(MOCK_MONO, index, false);

            let _ = font_ref_from_bytes(b"", index, false);

        }

    }

    // -----------------------------------------------------------------

    // PathLoader::new / load_from_path / load_font_shared

    // -----------------------------------------------------------------

    #[test]

    fn path_loader_new_is_a_zero_sized_stateless_handle() {

        assert_eq!(size_of::<PathLoader>(), 0);

        let a = PathLoader::new();

        let b = PathLoader;

        // both handles behave identically: no hidden per-instance state

        assert!(a.load_from_path(Path::new("/nonexistent/azul/x.ttf"), 0).is_err());

        assert!(b.load_from_path(Path::new("/nonexistent/azul/x.ttf"), 0).is_err());

    }

    #[test]

    fn load_from_path_missing_empty_and_directory_paths_are_font_not_found() {

        let loader = PathLoader::new();

        for path in [

            "",

            "/nonexistent/definitely/not/a/font.ttf",

            "/dev/null",

            env!("CARGO_MANIFEST_DIR"), // a directory, not a file

        ] {

            match loader.load_from_path(Path::new(path), 0) {

                Err(LayoutError::FontNotFound(selector)) => {

                    assert_eq!(selector.family, path, "the failing path is reported back");

                    assert!(selector.unicode_ranges.is_empty());

                }

                // /dev/null reads as zero bytes on Linux -> the parse fails instead

                Err(LayoutError::ShapingError(_)) => {}

                other => panic!("{path:?} must not load a font: {other:?}"),

            }

        }

    }

    #[test]

    fn load_from_path_parses_a_real_font_and_survives_extreme_indices() {

        let loader = PathLoader::new();

        let path = concat!(

            env!("CARGO_MANIFEST_DIR"),

            "/assets/fonts/test/azul-mock-mono.ttf"

        );

        let font_ref = loader

            .load_from_path(Path::new(path), 0)

            .expect("the positive control must load from disk");

        assert_eq!(font_ref.num_glyphs(), mock().num_glyphs());

        // 0 / MAX face index: either resolves or errors, but never panics

        for index in [0usize, 1, usize::MAX] {

            let _ = loader.load_from_path(Path::new(path), index);

        }

    }

    #[test]

    fn load_font_shared_rejects_empty_and_garbage_byte_blobs() {

        let loader = PathLoader::new();

        let cases: Vec<Vec<u8>> = vec![

            Vec::new(),

            b"   \t\n".to_vec(),

            vec![0xFF, 0xFE, 0x00],

            MOCK_MONO[..32].to_vec(),

            vec![0u8; 1_000_000],

        ];

        for bytes in cases {

            let shared = Arc::new(FontBytes::Owned(Arc::from(bytes)));

            match loader.load_font_shared(shared, 0) {

                Err(LayoutError::ShapingError(msg)) => assert!(!msg.is_empty()),

                other => panic!("garbage must not parse: {other:?}"),

            }

        }

    }

    #[test]

    fn load_font_shared_matches_the_eager_parse_and_tolerates_extreme_indices() {

        let loader = PathLoader::new();

        let shared = Arc::new(FontBytes::Owned(Arc::from(MOCK_MONO.to_vec())));

        let font_ref = loader

            .load_font_shared(Arc::clone(&shared), 0)

            .expect("the positive control must parse");

        let eager = mock();

        assert_eq!(font_ref.num_glyphs(), eager.num_glyphs());

        assert_eq!(font_ref.get_hash(), eager.get_hash());

        // font_index at the numeric extremes must not index out of bounds

        for index in [0usize, 1, usize::MAX] {

            let _ = loader.load_font_shared(Arc::clone(&shared), index);

        }

    }

    // -----------------------------------------------------------------

    // FontManager::evict_unused

    // -----------------------------------------------------------------

    #[test]

    fn evict_unused_on_an_empty_manager_is_zero_for_extreme_durations() {

        let manager: FontManager<FontRef> =

            FontManager::new(FcFontCache::default()).expect("an empty FontManager must build");

        // Duration::MAX truncates when cast to u64 nanos; with no faces cached

        // the result is 0 either way — the point is that it must not panic.

        for idle in [

            Duration::ZERO,

            Duration::from_nanos(1),

            Duration::from_secs(3600),

            Duration::MAX,

        ] {

            assert_eq!(manager.evict_unused(idle), 0);

        }

    }

    #[test]

    fn evict_unused_only_reclaims_stale_deferred_faces() {

        let manager: FontManager<FontRef> =

            FontManager::new(FcFontCache::default()).expect("an empty FontManager must build");

        let deferred = crate::parsed_font_to_font_ref(mock_deferred());

        let eager = crate::parsed_font_to_font_ref(mock());

        {

            let mut fonts = manager.parsed_fonts.lock().unwrap();

            fonts.insert(FontId::new(), deferred.clone());

            fonts.insert(FontId::new(), eager.clone());

        }

        // Nothing has decoded a glyph yet: the deferred face holds no LocaGlyf,

        // so there is nothing to release even though it is "never touched".

        assert_eq!(manager.evict_unused(Duration::ZERO), 0);

        // Touch the deferred face -> it materialises loca+glyf and stamps last_used.

        let parsed = crate::font_ref_to_parsed_font(&deferred);

        assert!(parsed.get_or_decode_glyph(1).is_some(), "gid 1 must decode");

        let _ = crate::font_ref_to_parsed_font(&eager).get_or_decode_glyph(1);

        // A face used microseconds ago is not idle for an hour.

        assert_eq!(manager.evict_unused(Duration::from_secs(3600)), 0);

        // With a zero idle window it is stale immediately. The eager face keeps

        // no source bytes, so it can never be evicted -> exactly one eviction.

        assert_eq!(manager.evict_unused(Duration::ZERO), 1);

        // Evicting twice is a no-op.

        assert_eq!(manager.evict_unused(Duration::ZERO), 0);

        // The evicted face still decodes: it re-parses from its retained bytes.

        assert!(parsed.get_or_decode_glyph(2).is_some());

    }

    // -----------------------------------------------------------------

    // shape_text_internal / shape_text_for_parsed_font / FontRef::shape_text

    // -----------------------------------------------------------------

    #[test]

    fn shape_text_empty_input_yields_no_glyphs() {

        let font = mock();

        let glyphs = shape(&font, "").expect("empty text is not an error");

        assert!(glyphs.is_empty());

        let via_public = shape_text_for_parsed_font(

            &font,

            "",

            Script::Latin,

            Language::EnglishUS,

            BidiDirection::Ltr,

            &style_at(16.0),

        )