DirectRectangle.cs

using System.Drawing;
using System.Runtime.CompilerServices;
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 DirectRectangle : DirectDrawingMovableBase
{
    public enum ImageFillMode
    {
        Stretch,

        Fit,

        Fill,

        Center,

        PixelPerfect,

        Repeat
    }
 
    private readonly SKPaint _fillPaint;        // cached fill
    private readonly SKPaint _strokePaint;      // cached stroke
    private readonly SKPaint _imagePaint = new()
    {
        IsAntialias = true,
        FilterQuality = SKFilterQuality.Medium,
        BlendMode = SKBlendMode.SrcOver
    };
 
    private SKColor? _borderColor;              // optional distinct border color
    private SKShader? _fillShader;              // optional fill shader
    private SKImage? _fillImage;
    private SKBitmap? _fillBitmap;
    private ImageFillMode _imageFillMode = ImageFillMode.Stretch;
    private float _imageScale = 1f;
    private SKPoint _imageOffsetPx;
    private bool _resourcesDisposed;
 
    private bool _isFilled;
    private float _cornerRadius;
    private float[]? _dashPattern;
    private StrokeAlign _strokeAlign = StrokeAlign.Center;
    private bool _needsRebuildPaints = true; // mark when properties change
 
    // --- Pulse settings ---
    private bool _pulseFillEnabled;
    private SKColor _pulseFillFrom, _pulseFillTo;
    private float _pulseFillPeriodSec = 1f;
 
    private bool _pulseBorderEnabled;
    private SKColor _pulseBorderFrom, _pulseBorderTo;
    private float _pulseBorderPeriodSec = 1f;
 
    private enum PulseWave
    {
        Sine,
        Triangle
    }
    private PulseWave _pulseFillWave = PulseWave.Sine;
    private PulseWave _pulseBorderWave = PulseWave.Sine;
 
    // --- Time keeping for Update(tick) ---
    private long _pulseLastTick = 0;
    private float _timeSec; // accumulated seconds
 
    private DirectRectangle(Color color,
                           RenderSurfaceHostBase renderSurfaceHost,
                           DirectDrawingMode mode,
                           SceneLayer? sceneLayer,
                           View? view,
                           Rectangle? screenBounds,
                           Rectangle? worldBounds,
                           string? nickname = null)
        : base(renderSurfaceHost, mode, sceneLayer, view, screenBounds, worldBounds, nickname)
    {
        // initialize with defaults; actual paints built lazily
        _fillPaint = new SKPaint { IsAntialias = true, Style = SKPaintStyle.Fill };
        _strokePaint = new SKPaint { IsAntialias = true, Style = SKPaintStyle.Stroke, StrokeWidth = 1 };
        SetColor(color);                 // sets base color and marks rebuild
        SetBlendMode(SKBlendMode.SrcOver);
        SetFilled(false);
    }

    public DirectRectangle(Color color,
                           RenderSurfaceHostBase renderSurfaceHost,
                           SceneLayer sceneLayer,
                           Rectangle worldBounds,
                           string? nickname = null)
        : this(color, renderSurfaceHost, DirectDrawingMode.SceneLayer, sceneLayer, null, null, worldBounds, nickname) { }

    public DirectRectangle(Color color,
                           RenderSurfaceHostBase renderSurfaceHost,
                           View view,
                           Rectangle screenBounds,
                           string? nickname = null)
        : this(color, renderSurfaceHost, DirectDrawingMode.View, null, view, screenBounds, null, nickname) { }

    public DirectRectangle SetColor(Color color)
    {
        // store as stroke/ fill base via rebuild
        var sk = color.ToSKColor();
        // Set on one paint; rebuild will propagate
        _fillPaint.Color = sk;
        _strokePaint.Color = sk;
        _needsRebuildPaints = true;
        return this;
    }

    public DirectRectangle SetBorderColor(Color color)
    {
        _borderColor = color.ToSKColor();
        _needsRebuildPaints = true;
        return this;
    }

    public DirectRectangle SetAlpha(int alpha)
    {
        var c = _fillPaint.Color;
        var withA = new SKColor(c.Red, c.Green, c.Blue, (byte)alpha);
        _fillPaint.Color = withA;
        // Only change stroke when it's not using a distinct border color
        if (_borderColor is null)
            _strokePaint.Color = withA;
        _needsRebuildPaints = true;
        return this;
    }

    public DirectRectangle SetFilled(bool isFilled)
    {
        _isFilled = isFilled;
        _needsRebuildPaints = true;
        return this;
    }

    public DirectRectangle SetStrokeWidth(float width)
    {
        _strokePaint.StrokeWidth = width;
        _needsRebuildPaints = true;
        return this;
    }

    public DirectRectangle SetCornerRadius(float radius)
    {
        _cornerRadius = radius;
        return this;
    }

    public DirectRectangle SetDashPattern(float dashLength, float gapLength)
    {
        _dashPattern = new[] { dashLength, gapLength };
        // path effect is applied on draw; no rebuild needed
        return this;
    }

    public DirectRectangle ClearDashPattern()
    {
        _dashPattern = null;
        return this;
    }

    public DirectRectangle SetBlendMode(SKBlendMode mode)
    {
        // apply to both paints
        _fillPaint.BlendMode = mode;
        _strokePaint.BlendMode = mode;
        _imagePaint.BlendMode = mode;
        // no rebuild needed
        return this;
    }

    public DirectRectangle SetStrokeAlign(StrokeAlign align)
    {
        _strokeAlign = align;
        return this;
    }

    public DirectRectangle PulseFill(Color from, Color to, float periodSec, bool enabled = true, bool triangle = false)
    {
        _pulseFillEnabled = enabled;
        _pulseFillFrom = from.ToSKColor();
        _pulseFillTo = to.ToSKColor();
        _pulseFillPeriodSec = MathF.Max(0.0001f, periodSec);
        _pulseFillWave = triangle ? PulseWave.Triangle : PulseWave.Sine;
        return this;
    }

    public DirectRectangle PulseBorder(Color from, Color to, float periodSec, bool enabled = true, bool triangle = false)
    {
        _pulseBorderEnabled = enabled;
        _pulseBorderFrom = from.ToSKColor();
        _pulseBorderTo = to.ToSKColor();
        _pulseBorderPeriodSec = MathF.Max(0.0001f, periodSec);
        _pulseBorderWave = triangle ? PulseWave.Triangle : PulseWave.Sine;
        return this;
    }

    public DirectRectangle StopPulses()
    {
        _pulseFillEnabled = _pulseBorderEnabled = false;
        RebuildPaints();   // restore fill/border to SetColor/SetBorderColor values
        ForceRefresh();
        return this;
    }

    public DirectRectangle SetFillPattern(SKBitmap bitmap,
                                          SKShaderTileMode tileX = SKShaderTileMode.Repeat,
                                          SKShaderTileMode tileY = SKShaderTileMode.Repeat,
                                          float scale = 1f,
                                          SKPoint? offsetPx = null,
                                          SKFilterQuality filterQuality = SKFilterQuality.None)
    {
        ArgumentNullException.ThrowIfNull(bitmap);
 
        scale = float.IsFinite(scale) && scale > 0f
            ? scale
            : throw new ArgumentOutOfRangeException(nameof(scale), "Pattern scale must be finite and greater than zero.");
 
        var m = SKMatrix.CreateScale(scale, scale);
        if (offsetPx is { } o)
            m = m.PostConcat(SKMatrix.CreateTranslation(o.X, o.Y));
 
        SKShader newShader = SKShader.CreateBitmap(bitmap, tileX, tileY, m);
 
        _fillPaint.Shader = null;
        _fillShader?.Dispose();
        _fillShader = newShader;
 
        _fillImage = null;
        _fillBitmap = null;
 
        _fillPaint.Shader = _fillShader;
        _fillPaint.FilterQuality = filterQuality; // or Low/Medium/High
 
        // Ensure we're in filled mode for visibility
        _isFilled = true;
        ForceRefresh();
        return this;
    }

    public DirectRectangle SetFillImage(
        SKBitmap bitmap,
        ImageFillMode mode = ImageFillMode.Stretch,
        float scale = 1f,
        SKPoint? offsetPx = null,
        SKFilterQuality filterQuality = SKFilterQuality.Medium)
    {
        ArgumentNullException.ThrowIfNull(bitmap);
 
        SetFillImageCore(
            image: null,
            bitmap: bitmap,
            mode: mode,
            scale: scale,
            offsetPx: offsetPx,
            filterQuality: filterQuality);
 
        return this;
    }

    public DirectRectangle SetFillImage(
        SKImage image,
        ImageFillMode mode = ImageFillMode.Stretch,
        float scale = 1f,
        SKPoint? offsetPx = null,
        SKFilterQuality filterQuality = SKFilterQuality.Medium)
    {
        ArgumentNullException.ThrowIfNull(image);
 
        SetFillImageCore(
            image: image,
            bitmap: null,
            mode: mode,
            scale: scale,
            offsetPx: offsetPx,
            filterQuality: filterQuality);
 
        return this;
    }

    public DirectRectangle ClearFillImage()
    {
        _fillImage = null;
        _fillBitmap = null;
        ForceRefresh();
        return this;
    }

    public DirectRectangle ClearFillPattern()
    {
        _fillPaint.Shader = null;
        _fillShader?.Dispose();
        _fillShader = null;
        ForceRefresh();
        return this;
    }

    public override void Update(long tick)
    {
        if (tick <= _lastTick)
            return;
 
        // no previous tick assume first frame, so skip dt-based updates
        if (_pulseLastTick > 0)
        {
            float dt = HighResTimer.GetDuration(_pulseLastTick, tick);
            _timeSec += dt;
        }
 
        _pulseLastTick = tick;
 
        bool changed = false;
 
        if (_pulseFillEnabled)
        {
            float t = PulseT(_timeSec, _pulseFillPeriodSec, _pulseFillWave);
            var c = LerpColor(_pulseFillFrom, _pulseFillTo, t);
            if (_fillPaint.Color != c) { _fillPaint.Color = c; changed = true; }
        }
 
        if (_pulseBorderEnabled)
        {
            float t = PulseT(_timeSec, _pulseBorderPeriodSec, _pulseBorderWave);
            var c = LerpColor(_pulseBorderFrom, _pulseBorderTo, t);
 
            if (_strokePaint.Color != c)
            {
                _strokePaint.Color = c;   // paint-only override
                ForceRefresh();
            }
        }
 
        if (changed)
        {
            _needsRebuildPaints = false;    // we already set paints directly
            ForceRefresh();                 // request redraw
        }
 
        base.Update(tick);
    }

    protected override void OnDraw(BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        if (backbuffer is RecordingBackbuffer && _fillImage?.IsTextureBacked == true)
            throw new NotSupportedException("Desktop frame recording requires a CPU image, not a context-bound texture.");
 
        var canvas = backbuffer.Canvas;
 
        if (_needsRebuildPaints)
            RebuildPaints();
 
        var fillRect = destRectScreen.ToSKRect();
        var strokeRect = fillRect;
 
        bool willDrawStroke = !_isFilled || _borderColor.HasValue || _strokePaint.StrokeWidth > 0.01f;
        float half = _strokePaint.StrokeWidth * 0.5f;
 
        // 1) APPLY STROKE ALIGNMENT (use HALF the width; path is centered)
        if (willDrawStroke && _strokeAlign != StrokeAlign.Center)
        {
            if (_strokeAlign == StrokeAlign.Inside)
                strokeRect.Inflate(-half, -half);
            else if (_strokeAlign == StrokeAlign.Outside)
                strokeRect.Inflate(half, half);
        }
 
        // 1.5) corner radius for the stroke path, adjusted to keep the inner/outer arcs aligned to the fill
        float strokeCornerRadius;
        switch (_strokeAlign)
        {
            case StrokeAlign.Outside:
                strokeCornerRadius = MathF.Max(0f, _cornerRadius - half);
                break;
            case StrokeAlign.Inside:
                strokeCornerRadius = _cornerRadius + half;
                break;
            case StrokeAlign.Center:
            default:
                strokeCornerRadius = _cornerRadius;
                break;
        }
 
        // 2) Dash for stroke only
        _strokePaint.PathEffect = _dashPattern is { Length: > 0 }
            ? SKPathEffect.CreateDash(_dashPattern, 0)
            : null;
 
        // 3) Draw fill (unmodified rect)
        if (_isFilled)
        {
            if (_fillImage is not null || _fillBitmap is not null)
            {
                DrawImageFill(canvas, fillRect);
            }
            else if (_cornerRadius > 0)
            {
                canvas.DrawRoundRect(fillRect, strokeCornerRadius, strokeCornerRadius, _fillPaint);
            }
            else
            {
                canvas.DrawRect(fillRect, _fillPaint);
            }
        }
 
        // 4) Draw stroke on its aligned rect (pure/opaque so it stays white)
        if (willDrawStroke)
        {
            var prevBlend = _strokePaint.BlendMode;
            var prevColor = _strokePaint.Color;
            var prevAA = _strokePaint.IsAntialias;
 
            _strokePaint.IsAntialias = false;
            _strokePaint.BlendMode = SKBlendMode.Src;
 
            // If pulsing, keep color from Update(),
            // else use base border color (or previous).
            var strokeColor = _pulseBorderEnabled ? _strokePaint.Color
                                                  : (_borderColor ?? prevColor);
 
            _strokePaint.Color = strokeColor.WithAlpha(255);
 
            if (_cornerRadius > 0)
                canvas.DrawRoundRect(strokeRect, _cornerRadius, _cornerRadius, _strokePaint);
            else
                canvas.DrawRect(strokeRect, _strokePaint);
 
            _strokePaint.IsAntialias = prevAA;
            _strokePaint.BlendMode = prevBlend;
            _strokePaint.Color = prevColor;
            _strokePaint.StrokeJoin = SKStrokeJoin.Round;
            _strokePaint.StrokeCap = SKStrokeCap.Round;
        }
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing && !_resourcesDisposed)
        {
            _resourcesDisposed = true;
            _fillPaint.Shader = null;
            _fillShader?.Dispose();
            _fillShader = null;
            _fillPaint.Dispose();
            _strokePaint.Dispose();
            _imagePaint.Dispose();
        }
 
        base.Dispose(disposing);
    }
 
    private void SetFillImageCore(
        SKImage? image,
        SKBitmap? bitmap,
        ImageFillMode mode,
        float scale,
        SKPoint? offsetPx,
        SKFilterQuality filterQuality)
    {
        if (!float.IsFinite(scale) || scale <= 0f)
            throw new ArgumentOutOfRangeException(nameof(scale), "Image scale must be finite and greater than zero.");
 
        if (!Enum.IsDefined(mode))
            throw new ArgumentOutOfRangeException(nameof(mode));
 
        _fillPaint.Shader = null;
        _fillShader?.Dispose();
        _fillShader = null;
 
        _fillImage = image;
        _fillBitmap = bitmap;
        _imageFillMode = mode;
        _imageScale = scale;
        _imageOffsetPx = offsetPx ?? SKPoint.Empty;
        _imagePaint.FilterQuality = filterQuality;
        _isFilled = true;
 
        ForceRefresh();
    }
 
    private void DrawImageFill(
        SKCanvas canvas,
        SKRect fillRect)
    {
        SKImage? image = _fillImage;
        SKBitmap? bitmap = _fillBitmap;
 
        int sourceWidth = image?.Width ?? bitmap?.Width ?? 0;
        int sourceHeight = image?.Height ?? bitmap?.Height ?? 0;
 
        if (sourceWidth <= 0 || sourceHeight <= 0)
            return;
 
        canvas.Save();
 
        try
        {
            using var clipPath = new SKPath();
 
            if (_cornerRadius > 0f)
                clipPath.AddRoundRect(fillRect, _cornerRadius, _cornerRadius);
            else
                clipPath.AddRect(fillRect);
 
            canvas.ClipPath(
                clipPath,
                SKClipOperation.Intersect,
                antialias: _cornerRadius > 0f);
 
            var source = new SKRect(
                0f,
                0f,
                sourceWidth,
                sourceHeight);
 
            if (_imageFillMode == ImageFillMode.Repeat)
            {
                if (image is not null)
                {
                    DrawRepeatedImage(
                        canvas,
                        image,
                        source,
                        fillRect);
                }
                else
                {
                    DrawRepeatedBitmap(
                        canvas,
                        bitmap!,
                        source,
                        fillRect);
                }
            }
            else
            {
                SKRect destination = ComputeImageDestination(
                    fillRect,
                    source,
                    _imageFillMode);
 
                if (image is not null)
                {
                    canvas.DrawImage(
                        image,
                        source,
                        destination,
                        _imagePaint);
                }
                else
                {
                    canvas.DrawBitmap(
                        bitmap!,
                        source,
                        destination,
                        _imagePaint);
                }
            }
        }
        finally
        {
            canvas.Restore();
        }
    }
 
    private void DrawRepeatedImage(
        SKCanvas canvas,
        SKImage image,
        SKRect source,
        SKRect fillRect)
    {
        float tileWidth = image.Width * _imageScale;
        float tileHeight = image.Height * _imageScale;
 
        float offsetX = PositiveModulo(_imageOffsetPx.X, tileWidth);
        float offsetY = PositiveModulo(_imageOffsetPx.Y, tileHeight);
 
        float startX = fillRect.Left + offsetX;
        float startY = fillRect.Top + offsetY;
 
        if (startX > fillRect.Left)
            startX -= tileWidth;
 
        if (startY > fillRect.Top)
            startY -= tileHeight;
 
        for (float y = startY; y < fillRect.Bottom; y += tileHeight)
        {
            for (float x = startX; x < fillRect.Right; x += tileWidth)
            {
                canvas.DrawImage(
                    image,
                    source,
                    new SKRect(
                        x,
                        y,
                        x + tileWidth,
                        y + tileHeight),
                    _imagePaint);
            }
        }
    }
 
    private void DrawRepeatedBitmap(
        SKCanvas canvas,
        SKBitmap bitmap,
        SKRect source,
        SKRect fillRect)
    {
        float tileWidth = bitmap.Width * _imageScale;
        float tileHeight = bitmap.Height * _imageScale;
 
        float offsetX = PositiveModulo(_imageOffsetPx.X, tileWidth);
        float offsetY = PositiveModulo(_imageOffsetPx.Y, tileHeight);
 
        float startX = fillRect.Left + offsetX;
        float startY = fillRect.Top + offsetY;
 
        if (startX > fillRect.Left)
            startX -= tileWidth;
 
        if (startY > fillRect.Top)
            startY -= tileHeight;
 
        for (float y = startY; y < fillRect.Bottom; y += tileHeight)
        {
            for (float x = startX; x < fillRect.Right; x += tileWidth)
            {
                canvas.DrawBitmap(
                    bitmap,
                    source,
                    new SKRect(
                        x,
                        y,
                        x + tileWidth,
                        y + tileHeight),
                    _imagePaint);
            }
        }
    }
 
    private static SKRect ComputeImageDestination(
        SKRect bounds,
        SKRect source,
        ImageFillMode mode)
    {
        if (mode == ImageFillMode.Stretch)
            return bounds;
 
        if (mode == ImageFillMode.Center)
        {
            float x = bounds.MidX - source.Width * 0.5f;
            float y = bounds.MidY - source.Height * 0.5f;
 
            return new SKRect(
                x,
                y,
                x + source.Width,
                y + source.Height);
        }
 
        float scaleX = bounds.Width / source.Width;
        float scaleY = bounds.Height / source.Height;
 
        float scale = mode switch
        {
            ImageFillMode.Fit => MathF.Min(scaleX, scaleY),
            ImageFillMode.Fill => MathF.Max(scaleX, scaleY),
            ImageFillMode.PixelPerfect => MathF.Max(
                1f,
                MathF.Floor(MathF.Min(scaleX, scaleY))),
            _ => 1f
        };
 
        float width = source.Width * scale;
        float height = source.Height * scale;
        float left = bounds.MidX - width * 0.5f;
        float top = bounds.MidY - height * 0.5f;
 
        return new SKRect(
            left,
            top,
            left + width,
            top + height);
    }
 
    private static float PositiveModulo(float value, float modulus)
    {
        float remainder = value % modulus;
        return remainder < 0f
            ? remainder + modulus
            : remainder;
    }

    private void RebuildPaints()
    {
        // Ensure styles/AA set
        _fillPaint.IsAntialias = true;
        _fillPaint.Style = SKPaintStyle.Fill;
 
        _strokePaint.IsAntialias = true;
        _strokePaint.Style = SKPaintStyle.Stroke;
 
        // Only rebuild stroke color if not pulsing border
        if (!_pulseBorderEnabled)
        {
            // If border color set, use it for stroke; else match fill/base color
            if (_borderColor.HasValue)
            {
                _ = _strokePaint.Color; // preserve alpha if you want; otherwise:
                _strokePaint.Color = _borderColor.Value;
            }
            else
            {
                _strokePaint.Color = _fillPaint.Color; // same as fill if no explicit border
            }
 
            _needsRebuildPaints = false;
        }
    }

    public enum StrokeAlign
    {
        Inside,

        Outside,

        Center
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static float PulseT(float timeSec, float periodSec, PulseWave wave)
    {
        float phase = (timeSec / periodSec) % 1f;
        if (wave == PulseWave.Sine)
        {
            // (sin(2πx)+1)/2 in [0..1]
            return 0.5f * (1f + MathF.Sin(phase * MathF.PI * 2f));
        }
        else // Triangle: ramp up 0..1 then down 1..0
        {
            return phase < 0.5f ? (phase * 2f) : (1f - ((phase - 0.5f) * 2f));
        }
    }
 
    [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 bch = (byte)(a.Blue + (b.Blue - a.Blue) * t01);
        byte aA = (byte)(a.Alpha + (b.Alpha - a.Alpha) * t01);
 
        return new SKColor(r, g, bch, aA);
    }
}