TextBlock.cs

using System.Drawing;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.SkiaSharp;
using Gondwana.Timers;
using SkiaSharp;
 
namespace Gondwana.Drawing.Direct;

public class TextBlock : DirectDrawingMovableBase
{
    public enum VerticalAlign
    {
        Top,
        Center,
        Bottom
    }
 
    #region events

    public event Action<string>? TextRevealed;

    public event Action<string>? TextRevealComplete;
 
    #endregion events
 
    private string _text = string.Empty;
    private readonly List<string> _lines = new();
    private float _lineHeight;
    private bool _layoutDirty = true;
 
    private SKColor _foreColor = SKColors.White;
    private SKColor _backColor = SKColors.Transparent;
 
    private float _fontSize = 16f;
    private float? _minFontSize = null;
    private SKTypeface? _typeface = null;
 
    private bool _useOutline = false;
    private bool _wrapText = true;
    private int? _maxLines = null;
 
    private bool _useShadow = false;
    private float _shadowDx = 2f, _shadowDy = 2f;
    private byte _shadowAlpha = 128;
    private float _shadowBlurSigma = 1.5f; // 0 = no blur
 
    private SKTextAlign _hAlign = SKTextAlign.Left;
    private VerticalAlign _vAlign = VerticalAlign.Top;
    private float _verticalScrollOffsetPx;
    private float _verticalScrollEndPaddingPx;
 
    // --- Pulse (text color) ---
    private bool _pulseTextEnabled;
    private SKColor _pulseFrom, _pulseTo;
    private float _pulsePeriodSec = 1f;
    private PulseWave _pulseWave = PulseWave.Sine;
 
    // timing
    private long? _pulseLastTick;
    private float _timeSec;
 
    // --- Text reveal animation ---
    private long _revealLastTick;
    private TextRevealMode _textRevealMode = TextRevealMode.None;
    private int _revealCharCount;        // how many chars currently visible
    private int _revealTargetCharCount;  // cap (usually Text.Length)
    private float _revealRate;             // cps or wps (depending on mode)
    private float _revealAccum;            // accumulator for dt-based stepping
 
    // precomputed for word-based reveal
    private int[]? _wordEndCharIndexes;    // end indexes (exclusive) per word
    private int _wordIndex;             // words shown so far
 
    // Punctuation pause tuning
    private bool _pauseEnabled = true;
    private float _pauseLongSec = 0.25f;
    private float _pauseShortSec = 0.10f;
 
    // current resolved color used for drawing (defaults to _foreColor)
    private SKColor _resolvedForeColor;

    private TextBlock(RenderSurfaceHostBase renderSurfaceHost,
                     DirectDrawingMode mode,
                     SceneLayer? sceneLayer,
                     View? view,
                     Rectangle? screenBounds,
                     Rectangle? worldBounds,
                     string? nickname = null)
        : base(renderSurfaceHost, mode, sceneLayer, view, screenBounds, worldBounds, nickname)
    {
        _resolvedForeColor = _foreColor;
    }

    public TextBlock(RenderSurfaceHostBase renderSurfaceHost,
                     SceneLayer sceneLayer,
                     View? view,
                     Rectangle worldBounds,
                     string? nickname = null)
        : this(renderSurfaceHost,
               DirectDrawingMode.SceneLayer,
               sceneLayer,
               view,
               screenBounds: null,
               worldBounds: worldBounds,
               nickname: nickname)
    { }

    public TextBlock(RenderSurfaceHostBase renderSurfaceHost,
                     View view,
                     Rectangle screenBounds,
                     string? nickname = null)
        : this(renderSurfaceHost,
               DirectDrawingMode.View,
               sceneLayer: null,
               view: view,
               screenBounds: screenBounds,
               worldBounds: null,
               nickname: nickname)
    { }

    public float LineSpacingMultiplier { get; set; } = 1.0f;

    public float HorizontalPadding { get; set; } = 0f;

    public float VerticalPadding { get; set; } = 0f;

    public float VerticalScrollOffsetPx
    {
        get => _verticalScrollOffsetPx;
        set
        {
            if (!float.IsFinite(value) || value < 0f)
                throw new ArgumentOutOfRangeException(nameof(value));
 
            if (Math.Abs(_verticalScrollOffsetPx - value) < 0.001f)
                return;
 
            _verticalScrollOffsetPx = value;
            ForceRefresh();
        }
    }

    public float VerticalScrollEndPaddingPx
    {
        get => _verticalScrollEndPaddingPx;
        set
        {
            if (!float.IsFinite(value) || value < 0f)
                throw new ArgumentOutOfRangeException(nameof(value));
 
            if (Math.Abs(_verticalScrollEndPaddingPx - value) < 0.001f)
                return;
 
            _verticalScrollEndPaddingPx = value;
            ForceRefresh();
        }
    }

    public float MeasureMaximumVerticalScrollOffsetPx()
    {
        Rectangle bounds = Mode == DirectDrawingMode.View ? ScreenBounds : WorldBounds;
        float innerWidth = Math.Max(0f, bounds.Width - HorizontalPadding * 2f);
        float innerHeight = Math.Max(0f, bounds.Height - VerticalPadding * 2f);
 
        _typeface ??= SKTypeface.Default;
        using var paint = new SKPaint
        {
            Typeface = _typeface,
            TextSize = _fontSize,
            TextAlign = _hAlign
        };
 
        float fontSize = _fontSize;
        float minimumFontSize = _minFontSize ?? 0f;
 
        while (true)
        {
            paint.TextSize = fontSize;
            RebuildLayout(paint, innerWidth);
 
            int drawableLines = _maxLines.HasValue
                ? Math.Min(_lines.Count, _maxLines.Value)
                : _lines.Count;
            float contentHeight = drawableLines * _lineHeight;
            bool exceedsHeight = contentHeight > innerHeight;
            bool exceedsWidth = _lines.Any(line => paint.MeasureText(line) > innerWidth);
 
            if (_minFontSize.HasValue &&
                (exceedsHeight || exceedsWidth) &&
                fontSize > minimumFontSize)
            {
                fontSize = Math.Max(minimumFontSize, fontSize - 1f);
                continue;
            }
 
            float maximumOffset = Math.Max(0f, contentHeight - innerHeight);
            if (maximumOffset > 0f)
                maximumOffset += VerticalScrollEndPaddingPx;
 
            // Measurement may have laid out at an auto-shrunk font size. Force the next draw
            // to rebuild from the configured font settings rather than reusing measurement state.
            _layoutDirty = true;
            return maximumOffset;
        }
    }

    public TextBlock SetPadding(float horizontal, float vertical)
    {
        if (!float.IsFinite(horizontal) || horizontal < 0f)
            throw new ArgumentOutOfRangeException(nameof(horizontal));
        if (!float.IsFinite(vertical) || vertical < 0f)
            throw new ArgumentOutOfRangeException(nameof(vertical));
 
        HorizontalPadding = horizontal;
        VerticalPadding = vertical;
        _layoutDirty = true;
        ForceRefresh();
        return this;
    }

    public TextBlock SetSize(Size size)
    {
        if (size.Width <= 0 || size.Height <= 0)
            throw new ArgumentOutOfRangeException(nameof(size), size, "Text block size must be positive.");
 
        if (Mode == DirectDrawingMode.View)
            ScreenBounds = new Rectangle(ScreenBounds.Location, size);
        else
            WorldBounds = new Rectangle(WorldBounds.Location, size);
 
        _layoutDirty = true;
        ForceRefresh();
        return this;
    }

    public TextBlock SetText(string text)
    {
        _text = text ?? string.Empty;
        _layoutDirty = true;
 
        if (_textRevealMode == TextRevealMode.None)
        {
            // when not revealing, default to fully visible
            _revealCharCount = _text.Length;
        }
        else
        {
            // keep the animation's target in sync with the new text
            _revealTargetCharCount = _text.Length;
 
            // if we had already revealed more than the new length, clamp it
            if (_revealCharCount > _revealTargetCharCount)
                _revealCharCount = _revealTargetCharCount;
 
            // optional: smooth start after text swap
            _revealAccum = 0f;
            // if you added a dedicated reveal timer, warm it so first frame doesn't "time-warp"
            _revealLastTick = 0;   // keep this if you're using the separate reveal timer
        }
 
        ForceRefresh();
        return this;
    }

    public TextBlock SetFont(SKTypeface typeface, float size, float? minSize = null)
    {
        _typeface = typeface;
        _fontSize = size;
        _minFontSize = minSize;
        _layoutDirty = true;
        ForceRefresh();
        return this;
    }

    public TextBlock SetColors(SKColor fg, SKColor bg)
    {
        _foreColor = fg;
        _backColor = bg;
        _resolvedForeColor = fg; // keep resolved in sync
        ForceRefresh();
        return this;
    }

    public TextBlock SetColors(Color fg, Color bg) => SetColors(fg.ToSKColor(), bg.ToSKColor());

    public TextBlock SetAlignment(SKTextAlign h, VerticalAlign v)
    {
        _hAlign = h;
        _vAlign = v;
        ForceRefresh();
        return this;
    }

    public TextBlock UseShadow(bool enable = true)
    {
        _useShadow = enable;
        ForceRefresh();
        return this;
    }

    public TextBlock SetShadow(float dx, float dy, byte alpha = 128, float blurSigma = 1.5f)
    {
        _shadowDx = dx;
        _shadowDy = dy;
        _shadowAlpha = alpha;
        _shadowBlurSigma = MathF.Max(0f, blurSigma);
        ForceRefresh();
        return this;
    }

    public TextBlock UseOutline(bool enable = true)
    {
        _useOutline = enable;
        ForceRefresh();
        return this;
    }

    public TextBlock EnableWrapping(bool enable = true)
    {
        _wrapText = enable;
        _layoutDirty = true;
        ForceRefresh();
        return this;
    }

    public TextBlock SetMaxLines(int? maxLines)
    {
        _maxLines = maxLines;
        ForceRefresh();
        return this;
    }

    public TextBlock PulseColor(Color from, Color to, float periodSec, bool enabled = true, bool triangle = false)
    {
        _pulseTextEnabled = enabled;
        _pulseFrom = from.ToSKColor();
        _pulseTo = to.ToSKColor();
        _pulsePeriodSec = MathF.Max(0.0001f, periodSec);
        _pulseWave = triangle ? PulseWave.Triangle : PulseWave.Sine;
 
        // start from base time; force a redraw
        _resolvedForeColor = _foreColor;
        ForceRefresh();
        return this;
    }

    public TextBlock StopColorPulse()
    {
        _pulseTextEnabled = false;
        _resolvedForeColor = _foreColor; // restore base
        ForceRefresh();
        return this;
    }

    public TextBlock StartTypewriter(float charsPerSecond,
                                     int? maxChars = null,
                                     bool enablePauses = true,
                                     float longPauseSec = 0.25f,
                                     float shortPauseSec = 0.10f)
    {
        _textRevealMode = TextRevealMode.CharactersPerSecond;
        _revealRate = MathF.Max(0f, charsPerSecond);
        _revealCharCount = 0;
        _revealTargetCharCount = maxChars.HasValue ? Math.Min(maxChars.Value, _text.Length) : _text.Length;
        _revealAccum = 0f;
        _wordEndCharIndexes = null;
 
        _revealLastTick = 0;
 
        // punctuation tuning
        _pauseEnabled = enablePauses;
        _pauseLongSec = longPauseSec;
        _pauseShortSec = shortPauseSec;
 
        ForceRefresh();
        return this;
    }

    public TextBlock StartWordReveal(float wordsPerSecond,
                                     bool enablePauses = true,
                                     float longPauseSec = 0.25f,
                                     float shortPauseSec = 0.10f)
    {
        _textRevealMode = TextRevealMode.WordsPerSecond;
        _revealRate = MathF.Max(0f, wordsPerSecond);
        _revealCharCount = 0;
        _revealTargetCharCount = _text.Length;
        _revealAccum = 0f;
        _wordIndex = 0;
 
        // split words once; keep trailing punctuation with the word so it reveals naturally
        // You can refine this regex to match your localization needs.
        _wordEndCharIndexes = Regex.Matches(_text, @"\S+\s*")
                                   .Select(m => m.Index + m.Length)
                                   .ToArray();
 
        _revealLastTick = 0;
 
        _pauseEnabled = enablePauses;
        _pauseLongSec = longPauseSec;
        _pauseShortSec = shortPauseSec;
 
        ForceRefresh();
        return this;
    }

    public TextBlock SetPunctuationPauses(bool enabled, float longPauseSec = 0.25f, float shortPauseSec = 0.10f)
    {
        _pauseEnabled = enabled;
        _pauseLongSec = longPauseSec;
        _pauseShortSec = shortPauseSec;
        return this;
    }

    public TextBlock RevealSetCount(int charCount)
    {
        _textRevealMode = TextRevealMode.ManualCount;
        _revealCharCount = Math.Clamp(charCount, 0, _text.Length);
        _revealTargetCharCount = _text.Length;
        ForceRefresh();
        return this;
    }

    public TextBlock RevealStop()
    {
        _textRevealMode = TextRevealMode.None;
        _revealCharCount = _text.Length;
 
        // Fire final events: first the revealed text (full), then the completion event
        TextRevealed?.Invoke(_text);
        TextRevealComplete?.Invoke(_text);
 
        ForceRefresh();
        return this;
    }
 
    private float PauseFor(char c)
    {
        if (!_pauseEnabled) return 0f;
 
        return c switch
        {
            '.' or '!' or '?' => _pauseLongSec,
            ',' or ';' or ':' => _pauseShortSec,
            _ => 0f
        };
    }

    public override void Update(long tick)
    {
        if (tick == _lastTick)
            return;
 
        // --- PULSE TIMING (independent) ---
        float dtPulse = 0f;
        if (_pulseLastTick.HasValue)
            dtPulse = HighResTimer.GetDuration(_pulseLastTick.Value, tick);
 
        _pulseLastTick = tick;
 
        if (dtPulse > 0f && dtPulse < 1f)
            _timeSec += dtPulse;
 
        if (_pulseTextEnabled)
        {
            float t = PulseT(_timeSec, _pulsePeriodSec, _pulseWave);
            var c = LerpColor(_pulseFrom, _pulseTo, t);
            if (c != _resolvedForeColor)
            {
                _resolvedForeColor = c;
                ForceRefresh();
            }
        }
        else
        {
            // keep resolved color at base if not pulsing
            if (_resolvedForeColor != _foreColor)
            {
                _resolvedForeColor = _foreColor;
                ForceRefresh();
            }
        }
 
        // --- REVEAL TIMING (independent and clamped) ---
        float dtReveal = 0f;
        if (_revealLastTick == 0)
        {
            _revealLastTick = tick;           // warm up: first frame uses 0 dt
        }
        else
        {
            dtReveal = HighResTimer.GetDuration(_revealLastTick, tick);
            _revealLastTick = tick;
 
            // Clamp to avoid first-frame "time warp" completing the whole text
            if (dtReveal > 0.1f) dtReveal = 0.1f;   // ~100ms/frame cap
            if (dtReveal < 0f) dtReveal = 0f;
        }
 
        // --- Typewriter / word reveal ---
        if (_textRevealMode == TextRevealMode.CharactersPerSecond)
        {
            _revealAccum += dtReveal;
            if (_revealRate > 0f)
            {
                int step = (int)(_revealAccum * _revealRate);
                if (step > 0)
                {
                    _revealAccum -= step / _revealRate;
 
                    int old = _revealCharCount;
                    _revealCharCount = Math.Min(_revealCharCount + step, _revealTargetCharCount);
 
                    // Punctuation pauses for newly revealed chars
                    for (int i = old; i < _revealCharCount; i++)
                        _revealAccum -= PauseFor(_text[i]);
 
                    // Mark dirty + redraw
                    ForceRefresh();
 
                    // Fire TextRevealed with the cumulative revealed text
                    if (_revealCharCount > old)
                    {
                        var revealed = _text.Substring(0, _revealCharCount);
                        TextRevealed?.Invoke(revealed);
                    }
 
                    // If we've reached the target, fire completion (TextRevealed already sent above)
                    if (_revealCharCount >= _revealTargetCharCount)
                    {
                        _textRevealMode = TextRevealMode.None;
                        // Ensure ordering: revealed then complete
                        TextRevealComplete?.Invoke(_text);
                    }
                }
            }
        }
        else if (_textRevealMode == TextRevealMode.WordsPerSecond && _wordEndCharIndexes is not null)
        {
            _revealAccum += dtReveal;
            if (_revealRate > 0f)
            {
                int step = (int)(_revealAccum * _revealRate);
                if (step > 0)
                {
                    _revealAccum -= step / _revealRate;
 
                    int oldCount = _revealCharCount;
 
                    _wordIndex = Math.Min(_wordIndex + step, _wordEndCharIndexes.Length);
                    _revealCharCount = _wordIndex == 0 ? 0 : _wordEndCharIndexes[_wordIndex - 1];
 
                    // Simple frontier pause (cheap). Loop oldCount.._revealCharCount-1 if you want per-char.
                    if (_revealCharCount > 0)
                        _revealAccum -= PauseFor(_text[_revealCharCount - 1]);
 
                    ForceRefresh();
 
                    // Fire TextRevealed with the cumulative revealed text
                    if (_revealCharCount > oldCount)
                    {
                        var revealed = _text.Substring(0, _revealCharCount);
                        TextRevealed?.Invoke(revealed);
                    }
 
                    if (_wordIndex >= _wordEndCharIndexes.Length)
                    {
                        _textRevealMode = TextRevealMode.None;
                        // Ensure ordering: revealed then complete
                        TextRevealComplete?.Invoke(_text);
                    }
                }
            }
        }
 
        // Let the base advance fade tween and set _lastTick
        base.Update(tick);
    }

    protected override void OnDraw(BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        var canvas = backbuffer.Canvas;
        var rect = destRectScreen.ToSKRect();
 
        float zoom = ResolveTextScale(Mode, RenderContext.Current?.ViewportZoom ?? 1f);
 
        // Scale "pixel-like" adornments with zoom so text behaves like other world-space drawables.
        float hPad = HorizontalPadding * zoom;
        float vPad = VerticalPadding * zoom;
        float shadowDx = _shadowDx * zoom;
        float shadowDy = _shadowDy * zoom;
        float shadowBlur = _shadowBlurSigma * zoom;
        float outlineWidth = 1.5f * zoom;
 
        // Background
        if (_backColor.Alpha != 0)
        {
            using var bg = new SKPaint { Color = _backColor };
            canvas.DrawRect(rect, bg);
        }
 
        _typeface ??= SKTypeface.Default;
 
        // Build a paint we can reuse for layout + draw (TEXT SIZE IS IN SCREEN PIXELS)
        using var paint = new SKPaint
        {
            Typeface = _typeface ?? SKTypeface.Default,
            TextSize = _fontSize * zoom,
            Color = _resolvedForeColor,
            IsAntialias = true,
            IsStroke = false,
            TextAlign = _hAlign
        };
 
        // Auto-shrink: reflow until it fits height (if min size provided)
        float fontSize = _fontSize * zoom;
        float minFontSize = _minFontSize.HasValue ? _minFontSize.Value * zoom : 0f;
 
        float innerW = Math.Max(0, rect.Width - hPad * 2f);
        float innerH = Math.Max(0, rect.Height - vPad * 2f);
 
        while (true)
        {
            paint.TextSize = fontSize;
 
            // Rebuild when flagged, and also whenever zoom is in play so wrap/line-height stay correct.
            if (_layoutDirty || zoom != 1f)
                RebuildLayout(paint, innerW);
 
            int drawableLines = _maxLines.HasValue ? Math.Min(_lines.Count, _maxLines.Value) : _lines.Count;
            float totalH = drawableLines * _lineHeight;
 
            bool exceedsHeight = totalH > innerH;
            bool exceedsWidth = _lines.Any(line => paint.MeasureText(line) > innerW);
 
            if (_minFontSize.HasValue &&
                (exceedsHeight || exceedsWidth) &&
                fontSize > minFontSize)
            {
                fontSize = Math.Max(minFontSize, fontSize - 1f);
                _layoutDirty = true;
 
                if (fontSize <= minFontSize)
                    break;
 
                continue;
            }
 
            break;
        }
 
        // Determine how many characters are currently visible (content-driven reveal)
        int visibleChars = _textRevealMode != TextRevealMode.None
            ? Math.Clamp(_revealCharCount, 0, _text.Length)
            : _text.Length;
 
        // Build the set of lines to draw from the already-laid-out _lines,
        // truncating at 'visibleChars' so wrapping and alignment still work.
        List<string> drawLines = new(_lines.Count);
        if (visibleChars <= 0)
        {
            // nothing to show
        }
        else if (visibleChars >= _text.Length)
        {
            drawLines.AddRange(_lines);
        }
        else
        {
            int remaining = visibleChars;
            foreach (var ln in _lines)
            {
                if (remaining <= 0)
                    break;
 
                if (ln.Length <= remaining)
                {
                    drawLines.Add(ln);
                    remaining -= ln.Length;
                }
                else
                {
                    drawLines.Add(ln.Substring(0, remaining));
                    remaining = 0;
                }
            }
        }
 
        bool wasTruncatedByMaxLines = _maxLines.HasValue && drawLines.Count > _maxLines.Value;
 
        // Apply max-lines cap at draw time
        int linesToDraw = _maxLines.HasValue ? Math.Min(drawLines.Count, _maxLines.Value) : drawLines.Count;
 
        if (linesToDraw > 0 && wasTruncatedByMaxLines)
        {
            drawLines[linesToDraw - 1] = FitLineWithEllipsis(paint, drawLines[linesToDraw - 1], innerW);
        }
 
        // Vertical start (Skia draws at baseline, so apply ascent shift)
        var fm = paint.FontMetrics;
        float baselineShift = -fm.Ascent;
 
        float contentH = linesToDraw * _lineHeight;
        float maximumScrollOffset = Math.Max(0f, contentH - innerH);
        if (maximumScrollOffset > 0f)
            maximumScrollOffset += VerticalScrollEndPaddingPx;
        float yStart = maximumScrollOffset > 0f
            ? rect.Top + vPad
            : _vAlign switch
            {
                VerticalAlign.Center => rect.Top + vPad + Math.Max(0, (innerH - contentH) * 0.5f),
                VerticalAlign.Bottom => rect.Bottom - vPad - contentH,
                _ => rect.Top + vPad
            };
 
        float scrollOffset = Math.Min(_verticalScrollOffsetPx * zoom, maximumScrollOffset);
        yStart -= scrollOffset;
 
        // Horizontal anchor per line
        float xAnchorLeft = rect.Left + hPad;
        float xAnchorCenter = rect.MidX;
        float xAnchorRight = rect.Right - hPad;
 
        canvas.Save();
        canvas.ClipRect(rect);
 
        float y = yStart;
        for (int i = 0; i < linesToDraw; i++)
        {
            var line = drawLines[i];
            float x = _hAlign switch
            {
                SKTextAlign.Center => xAnchorCenter,
                SKTextAlign.Right => xAnchorRight,
                _ => xAnchorLeft
            };
 
            if (_useShadow)
            {
                using var shadow = paint.Clone();
                shadow.IsStroke = false;
                shadow.MaskFilter = shadowBlur > 0f
                    ? SKMaskFilter.CreateBlur(SKBlurStyle.Normal, shadowBlur)
                    : null;
                shadow.Color = new SKColor(0, 0, 0, _shadowAlpha);
 
                // manually offset
                canvas.DrawText(line, x + shadowDx, y + baselineShift + shadowDy, shadow);
            }
 
            if (_useOutline)
            {
                using var outline = paint.Clone();
                outline.IsStroke = true;
                outline.StrokeWidth = outlineWidth;
                outline.Color = SKColors.Black;
                canvas.DrawText(line, x, y + baselineShift, outline);
            }
 
            canvas.DrawText(line, x, y + baselineShift, paint);
            y += _lineHeight;
 
            // safety clip
            if (y > rect.Bottom)
                break;
        }
 
        canvas.Restore();
    }
 
    internal static float ResolveTextScale(DirectDrawingMode mode, float viewportZoom)
    {
        if (mode != DirectDrawingMode.SceneLayer)
            return 1f;
 
        return viewportZoom > 0f ? viewportZoom : 1f;
    }
 
    private void RebuildLayout(SKPaint paint, float maxWidth)
    {
        _lines.Clear();
 
        var fm = paint.FontMetrics;
        _lineHeight = ((fm.Descent - fm.Ascent) + fm.Leading) * LineSpacingMultiplier;
 
        var paragraphs = _text.Replace("\r\n", "\n").Split('\n');
 
        foreach (var para in paragraphs)
        {
            if (string.IsNullOrEmpty(para))
            {
                _lines.Add(string.Empty);
                continue;
            }
 
            if (!_wrapText)
            {
                _lines.Add(para);
                continue;
            }
 
            var words = para.Split(' ', StringSplitOptions.None);
            var current = string.Empty;
 
            foreach (var word in words)
            {
                string candidate = string.IsNullOrEmpty(current) ? word : current + " " + word;
                float candidateWidth = paint.MeasureText(candidate);
 
                if (candidateWidth <= maxWidth)
                {
                    current = candidate;
                    continue;
                }
 
                // If current already has content, commit it first and retry this word on a new line.
                if (!string.IsNullOrEmpty(current))
                {
                    _lines.Add(current);
                    current = string.Empty;
                }
 
                // If the single word fits on its own line, use it.
                if (paint.MeasureText(word) <= maxWidth)
                {
                    current = word;
                    continue;
                }
 
                // Fallback: hard-break an overlong word by character.
                var chunk = string.Empty;
                foreach (char ch in word)
                {
                    string next = chunk + ch;
                    if (paint.MeasureText(next) <= maxWidth || string.IsNullOrEmpty(chunk))
                    {
                        chunk = next;
                    }
                    else
                    {
                        _lines.Add(chunk);
                        chunk = ch.ToString();
                    }
                }
 
                if (!string.IsNullOrEmpty(chunk))
                    current = chunk;
            }
 
            if (!string.IsNullOrEmpty(current))
                _lines.Add(current);
        }
 
        _layoutDirty = false;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static float PulseT(float timeSec, float periodSec, PulseWave wave)
    {
        float phase = (timeSec / periodSec) % 1f;
        return wave == PulseWave.Sine
            ? 0.5f * (1f + MathF.Sin(phase * MathF.PI * 2f))             // [0..1]
            : (phase < 0.5f ? phase * 2f : 1f - (phase - 0.5f) * 2f);    // triangle
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static SKColor LerpColor(SKColor a, SKColor b, float t01)
    {
        t01 = Math.Clamp(t01, 0f, 1f);
        byte r = (byte)(a.Red + (b.Red - a.Red) * t01);
        byte g = (byte)(a.Green + (b.Green - a.Green) * t01);
        byte bl = (byte)(a.Blue + (b.Blue - a.Blue) * t01);
        byte al = (byte)(a.Alpha + (b.Alpha - a.Alpha) * t01);
        return new SKColor(r, g, bl, al);
    }
 
    private static string FitLineWithEllipsis(SKPaint paint, string text, float maxWidth)
    {
        const string ellipsis = "...";
 
        if (string.IsNullOrEmpty(text))
            return text;
 
        if (paint.MeasureText(text) <= maxWidth)
            return text;
 
        float ellipsisWidth = paint.MeasureText(ellipsis);
        if (ellipsisWidth > maxWidth)
            return string.Empty;
 
        int length = text.Length;
        while (length > 0)
        {
            string candidate = text.Substring(0, length).TrimEnd() + ellipsis;
            if (paint.MeasureText(candidate) <= maxWidth)
                return candidate;
 
            length--;
        }
 
        return ellipsisWidth <= maxWidth ? ellipsis : string.Empty;
    }
 
    #region public readonly properties

    public string Text => _text;

    public List<string> Lines => _lines;

    public float LineHeight => _lineHeight;

    public SKColor ForeColor => _foreColor;

    public SKColor BackColor => _backColor;

    public float FontSize => _fontSize;

    public float? MinFontSize => _minFontSize;

    public SKTypeface? TypeFace => _typeface;

    public bool OutlineEnabled => _useOutline;

    public bool WrapText => _wrapText;

    public int? MaxLines => _maxLines;

    public bool ShadowEnabled => _useShadow;

    public float ShadowDx => _shadowDx;

    public float ShadowDy => _shadowDy;

    public byte ShadowAlpha => _shadowAlpha;

    public float ShadowBlurSigma => _shadowBlurSigma;

    public SKTextAlign AlignHoriz => _hAlign;

    public VerticalAlign AlignVert => _vAlign;

    public bool PulseTextEnabled => _pulseTextEnabled;

    public SKColor PulseFrom => _pulseFrom;

    public SKColor PulseTo => _pulseTo;

    public float PulsePeriodSec => _pulsePeriodSec;

    public PulseWave PulseWaveValue => _pulseWave;

    public TextRevealMode TextRevealModeValue => _textRevealMode;

    public float TextRevealRate => _revealRate;

    public bool PuctuationPauseEnabled => _pauseEnabled;

    public float PunctuationPauseLongSec => _pauseLongSec;

    public float PunctuationPauseShortSec => _pauseShortSec;

    public SKColor ResolvedForeColor => _resolvedForeColor;
 
    #endregion public readonly properties

    public enum PulseWave
    {
        Sine,
        Triangle
    }

    public enum TextRevealMode
    {
        None,
        CharactersPerSecond,
        WordsPerSecond,
        ManualCount
    }
 
    private readonly object _eventLock = new();

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            lock (_eventLock)
            {
                TextRevealed = null;
                TextRevealComplete = null;
            }
        }
 
        base.Dispose(disposing);
    }
}