using System.Collections.Generic;
using System.Globalization;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;

namespace ytLive.Services.Compositor;

/// <summary>
/// Rasterizes the stream-alert ticker into a transparent BGRA strip that the
/// output compositor overlays along the very top edge of the master frame
/// (TASK 47). The strip is text ("Viewer — Super Chat · $12.34") inside a dark
/// pill with the LlamaCasty accent bar, rendered ONCE per unique text on the UI
/// thread (WPF <c>RenderTargetBitmap</c>, Pbgra32→straight-alpha like
/// <see cref="SocialBarRenderer"/>), then cached. Each <see cref="Render"/> call
/// is pure byte-math on that cached raster producing a scrolling marquee frame,
/// so the frame pump can call it from any thread for every output frame at
/// 30fps without a Dispatcher round-trip.
/// </summary>
public static class AlertTickerRenderer
{
    /// <summary>Master-frame width — the ticker spans the full 1920px output.</summary>
    public const int Width = 1920;

    /// <summary>Strip height (pill + vertical padding).</summary>
    public const int Height = 48;

    private const int PixelsPerSecond = 140;
    private const int RepeatGap = 120;
    private const int CacheLimit = 48;

    private static readonly object Gate = new();
    private static readonly Dictionary<string, VideoFrame> StripCache = new();

    /// <summary>A marquee frame of <paramref name="text"/> scrolled
    /// <paramref name="elapsedSeconds"/> into its loop, or null for empty text.
    /// Thread-safe: reads the cached raster and does row copies only.</summary>
    public static VideoFrame? Render(string? text, double elapsedSeconds)
    {
        if (string.IsNullOrWhiteSpace(text)) return null;
        var strip = GetStrip(text!);
        if (strip == null) return null;

        var sw = strip.Width;
        var cycle = Width + sw + RepeatGap;
        var pos = (int)(elapsedSeconds * PixelsPerSecond) % cycle;
        var x = Width - pos;

        var pixels = new byte[Width * Height * 4];
        CopyStrip(pixels, strip, x);
        if (x < 0)
            CopyStrip(pixels, strip, x + Width + RepeatGap); // wrapped tail enters from the right
        return new VideoFrame(Width, Height, pixels);
    }

    private static void CopyStrip(byte[] dst, VideoFrame strip, int dstX)
    {
        if (dstX >= Width || dstX + strip.Width <= 0) return;
        var x0 = Math.Max(0, dstX);
        var x1 = Math.Min(Width, dstX + strip.Width);
        var sx0 = x0 - dstX;
        var copyBytes = (x1 - x0) * 4;
        var sw = strip.Width;
        for (var y = 0; y < strip.Height; y++)
            Buffer.BlockCopy(strip.BgraPixels, (y * sw + sx0) * 4, dst, (y * Width + x0) * 4, copyBytes);
    }

    private static VideoFrame? GetStrip(string text)
    {
        lock (Gate)
        {
            if (StripCache.TryGetValue(text, out var cached)) return cached;
        }
        var strip = RenderStrip(text);
        if (strip == null) return null;
        lock (Gate)
        {
            if (StripCache.Count >= CacheLimit) StripCache.Clear();
            if (!StripCache.TryGetValue(text, out var existing))
                StripCache[text] = strip;
            return StripCache[text];
        }
    }

    private static VideoFrame? RenderStrip(string text)
    {
        // WPF rendering is single-threaded; the pump thread resolves to the UI
        // thread at most once per unique text (then hits the cache).
        var app = Application.Current;
        if (app != null && !app.Dispatcher.CheckAccess())
        {
            VideoFrame? result = null;
            app.Dispatcher.Invoke(() => result = RenderStrip(text));
            return result;
        }

        const double pillHeight = 34;
        const double accentW = 6;
        const double padX = 16;
        const double gap = 8;

        var font = new Typeface(new FontFamily("Segoe UI"), FontStyles.Normal, FontWeights.SemiBold, FontStretches.Normal);
        var ft = new FormattedText(text, CultureInfo.InvariantCulture, FlowDirection.LeftToRight,
            font, 22, Brushes.White, 1.0);

        var pillW = (int)Math.Ceiling(padX + accentW + gap + ft.Width + padX);
        var top = (Height - pillHeight) / 2.0;
        var textTop = top + (pillHeight - ft.Height) / 2.0;

        var visual = new DrawingVisual();
        using (var dc = visual.RenderOpen())
        {
            var pill = new Rect(0, top, pillW, pillHeight);
            dc.DrawRoundedRectangle(new SolidColorBrush(Color.FromArgb(0xE6, 0x10, 0x13, 0x24)), null, pill, pillHeight / 2, pillHeight / 2);
            dc.DrawRoundedRectangle(new SolidColorBrush(Color.FromRgb(0xe9, 0x45, 0x60)), null,
                new Rect(padX, top + (pillHeight - 12) / 2.0, accentW, 12), 2, 2);
            dc.DrawText(ft, new Point(padX + accentW + gap, textTop));
        }

        var bitmap = new RenderTargetBitmap(pillW, Height, 96, 96, PixelFormats.Pbgra32);
        bitmap.Render(visual);

        var pixels = new byte[pillW * Height * 4];
        bitmap.CopyPixels(pixels, pillW * 4, 0);

        // Pbgra32 is premultiplied — unpremultiply so the compositor's
        // straight-alpha source-over doesn't halo the text edges.
        for (var i = 0; i < pixels.Length; i += 4)
        {
            var a = pixels[i + 3];
            if (a == 0 || a == 255) continue;
            pixels[i] = (byte)(pixels[i] * 255 / a);
            pixels[i + 1] = (byte)(pixels[i + 1] * 255 / a);
            pixels[i + 2] = (byte)(pixels[i + 2] * 255 / a);
        }
        return new VideoFrame(pillW, Height, pixels);
    }
}