func (ts *TextShape) Bounds() Rect {
	if ts.path == nil {
		return EmptyRect()
	}
	return ts.path.Bounds()
}

func (r *TextRenderer) Config() TextRendererConfig {
	r.mu.RLock()
	defer r.mu.RUnlock()
	return r.config
}

func DefaultTextRendererConfig() TextRendererConfig {
	return TextRendererConfig{
		FlipY:			false,
		SubpixelPositioning:	true,
		HintingEnabled:		false,
	}
}

func (s *Scene) DrawGlyphs(str string, glyphs []text.ShapedGlyph, face text.Face, x, y float32, brush Brush) error {
	if len(glyphs) == 0 {
		return nil
	}
	if face == nil {
		return &text.FontError{Reason: "face is nil"}
	}

	return s.encodeTextRun(str, glyphs, face, x, y, brush)
}

func (s *Scene) DrawText(str string, face text.Face, x, y float32, brush Brush) error {
	if str == "" {
		return nil
	}
	if face == nil {
		return &text.FontError{Reason: "face is nil"}
	}

	shaped := text.Shape(str, face)
	if len(shaped) == 0 {
		return nil
	}

	return s.encodeTextRun(str, shaped, face, x, y, brush)
}

func (p *TextRendererPool) Get() *TextRenderer {
	return p.pool.Get().(*TextRenderer)
}

func NewTextRenderer() *TextRenderer {
	return NewTextRendererWithConfig(DefaultTextRendererConfig())
}

func NewTextRendererPool() *TextRendererPool {
	return &TextRendererPool{
		pool: sync.Pool{
			New: func() any {
				return NewTextRenderer()
			},
		},
	}
}

func NewTextRendererWithConfig(config TextRendererConfig) *TextRenderer {
	return &TextRenderer{
		extractor:	text.NewOutlineExtractor(),
		pathPool:	NewPathPool(),
		config:		config,
	}
}

func NewTextShape(str string, face text.Face, x, y float32) (*TextShape, error) {
	if str == "" {
		return &TextShape{path: NewPath()}, nil
	}

	renderer := NewTextRenderer()
	rendered, err := renderer.RenderText(str, face)
	if err != nil {
		return nil, err
	}

	// Combine all glyph paths with offset
	composite := NewPath()
	for _, rg := range rendered {
		if rg.Path != nil && !rg.Path.IsEmpty() {
			// Transform path to final position
			transformed := rg.Path.Transform(TranslateAffine(x, y))
			appendPath(composite, transformed)
		}
	}

	return &TextShape{path: composite}, nil
}

func (p *TextRendererPool) Put(r *TextRenderer) {
	if r != nil {
		p.pool.Put(r)
	}
}

func (r *TextRenderer) RenderGlyph(glyph text.ShapedGlyph, face text.Face) (*RenderedGlyph, error) {
	r.mu.RLock()
	config := r.config
	r.mu.RUnlock()

	// Get the font source and size
	source := face.Source()
	if source == nil {
		return nil, &text.FontError{Reason: "face has no font source"}
	}
	size := face.Size()
	parsed := source.Parsed()

	cache := r.ensureCache()
	fontID := computeSceneTextFontID(source)
	sizeKey := computeSizeKey(size)

	cacheKey := text.OutlineCacheKey{
		FontID:		fontID,
		GID:		glyph.GID,
		Size:		sizeKey,
		Hinting:	text.HintingNone,
	}
	outline := cache.GetOrCreate(cacheKey, func() *text.GlyphOutline {
		o, err := r.extractor.ExtractOutline(parsed, glyph.GID, size)
		if err != nil || o == nil || o.IsEmpty() {
			return nil
		}
		return o
	})

	// Create the rendered glyph
	rendered := &RenderedGlyph{
		Advance:	float32(glyph.XAdvance),
		X:		float32(glyph.X),
		Y:		float32(glyph.Y),
		GID:		glyph.GID,
		Type:		text.GlyphTypeOutline,
		Cluster:	glyph.Cluster,
	}

	// Handle empty outlines (like space)
	if outline == nil {
		rendered.Path = nil
		rendered.Bounds = EmptyRect()
		return rendered, nil
	}

	// Convert outline to path with positioning
	path := r.outlineToPath(outline, float32(glyph.X), float32(glyph.Y), config)
	rendered.Path = path
	rendered.Bounds = path.Bounds()

	return rendered, nil
}

func (r *TextRenderer) RenderGlyphs(glyphs []text.ShapedGlyph, face text.Face) ([]*RenderedGlyph, error) {
	if len(glyphs) == 0 {
		return nil, nil
	}

	r.mu.RLock()
	config := r.config
	r.mu.RUnlock()

	// Get the font source and size
	source := face.Source()
	if source == nil {
		return nil, &text.FontError{Reason: "face has no font source"}
	}
	size := face.Size()
	parsed := source.Parsed()

	cache := r.ensureCache()
	fontID := computeSceneTextFontID(source)
	sizeKey := computeSizeKey(size)

	// Render all glyphs
	rendered := make([]*RenderedGlyph, len(glyphs))
	for i, glyph := range glyphs {
		rg := &RenderedGlyph{
			Advance:	float32(glyph.XAdvance),
			X:		float32(glyph.X),
			Y:		float32(glyph.Y),
			GID:		glyph.GID,
			Type:		text.GlyphTypeOutline,
			Cluster:	glyph.Cluster,
		}

		cacheKey := text.OutlineCacheKey{
			FontID:		fontID,
			GID:		glyph.GID,
			Size:		sizeKey,
			Hinting:	text.HintingNone,
		}
		outline := cache.GetOrCreate(cacheKey, func() *text.GlyphOutline {
			o, err := r.extractor.ExtractOutline(parsed, glyph.GID, size)
			if err != nil || o == nil || o.IsEmpty() {
				return nil
			}
			return o
		})

		if outline == nil {
			rg.Path = nil
			rg.Bounds = EmptyRect()
			rendered[i] = rg
			continue
		}

		// Convert to path
		path := r.outlineToPath(outline, float32(glyph.X), float32(glyph.Y), config)
		rg.Path = path
		rg.Bounds = path.Bounds()
		rendered[i] = rg
	}

	return rendered, nil
}

func (r *TextRenderer) RenderRun(run *text.ShapedRun) ([]*RenderedGlyph, error) {
	if run == nil || len(run.Glyphs) == 0 {
		return nil, nil
	}
	return r.RenderGlyphs(run.Glyphs, run.Face)
}

func (r *TextRenderer) RenderText(str string, face text.Face) ([]*RenderedGlyph, error) {
	if str == "" {
		return nil, nil
	}

	// Shape the text
	shaped := text.Shape(str, face)
	if len(shaped) == 0 {
		return nil, nil
	}

	return r.RenderGlyphs(shaped, face)
}

func (r *TextRenderer) SetConfig(config TextRendererConfig) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.config = config
}

func TextAdvance(glyphs []*RenderedGlyph) float32 {
	if len(glyphs) == 0 {
		return 0
	}

	// The advance is the position of the last glyph plus its advance
	last := glyphs[len(glyphs)-1]
	return last.X + last.Advance
}

func TextBounds(glyphs []*RenderedGlyph) Rect {
	if len(glyphs) == 0 {
		return EmptyRect()
	}

	bounds := EmptyRect()
	for _, rg := range glyphs {
		if rg.Path != nil {
			bounds = bounds.Union(rg.Bounds)
		}
	}

	return bounds
}

func (r *TextRenderer) ToCompositePath(glyphs []*RenderedGlyph) *Path {
	if len(glyphs) == 0 {
		return nil
	}

	composite := NewPath()
	for _, rg := range glyphs {
		if rg.Path != nil && !rg.Path.IsEmpty() {
			appendPath(composite, rg.Path)
		}
	}

	return composite
}

func (ts *TextShape) ToPath() *Path {
	return ts.path
}

type TextRenderer struct {
	mu	sync.RWMutex

	// extractor extracts glyph outlines from fonts
	extractor	*text.OutlineExtractor

	// pathPool reuses Path objects to reduce allocations
	pathPool	*PathPool

	// config holds renderer configuration
	config	TextRendererConfig

	// cache holds cached glyph outlines (lazy-initialized from global)
	cache	*text.GlyphCache
}

type TextRendererConfig struct {
	// FlipY inverts the Y-axis for glyph outlines (default: false).
	// Our OutlineExtractor preserves sfnt's Y-down convention
	// (Y=0 at baseline, Y<0 above, Y>0 below), which matches
	// screen coordinates directly. Set to true only if your
	// coordinate system has Y increasing upward.
	FlipY	bool

	// SubpixelPositioning enables fractional glyph positioning.
	// When false, glyphs are snapped to integer pixel positions.
	SubpixelPositioning	bool

	// HintingEnabled enables font hinting for sharper rendering at small sizes.
	HintingEnabled	bool
}

type RenderedGlyph struct {
	// Path is the vector path representing the glyph outline.
	// May be nil for non-outline glyphs (bitmap, empty).
	Path	*Path

	// Bounds is the bounding box of the rendered glyph.
	Bounds	Rect

	// Advance is the distance to the next glyph position.
	Advance	float32

	// Position is the glyph position relative to the text origin.
	X, Y	float32

	// GID is the glyph ID.
	GID	text.GlyphID

	// Type indicates the glyph type.
	Type	text.GlyphType

	// Cluster is the source character index.
	Cluster	int
}

type TextRendererPool struct {
	pool sync.Pool
}

type TextShape struct {
	path *Path
}