using ytLive.Services;

namespace ytLive.ViewModels;

public partial class MainViewModel
{
    /// <summary>The branding credit as the preview pane shows it: a master-space
    /// bitmap, or null while no credit is playing. It is the SAME frame the encoder
    /// composites into the recording/stream (<see cref="BrandFlashFrame"/>), so what
    /// the creator sees is what the viewers get — the old preview-only TextBlock lied
    /// about this, and a 1080p credit that is only in the preview is not advertising
    /// anyone. It cannot ride a per-source <c>VideoImageSource</c>: it is a global
    /// overlay, like the social bar and the alert ticker.</summary>
    private System.Windows.Media.Imaging.WriteableBitmap? _brandFlashBitmap;

    public System.Windows.Media.Imaging.WriteableBitmap? BrandFlashImageSource
    {
        get => _brandFlashBitmap;
        private set
        {
            _brandFlashBitmap = value;
            OnPropertyChanged(nameof(BrandFlashImageSource));
            OnPropertyChanged(nameof(BrandFlashVisible));
        }
    }

    public bool BrandFlashVisible => _brandFlashBitmap != null;

    /// <summary>The credit for the output compositor, or null when none is due. Read by
    /// the frame pump every output frame; <c>null</c> for a premium user, always —
    /// the licence check lives inside the presenter so no caller can bypass it.</summary>
    public VideoFrame? BrandFlashFrame() => _brandFlash.Frame;

    /// <summary>Test-only seam: advances the credit's clock deterministically, exactly
    /// like <see cref="Services.BrandFlashPresenter.Advance"/>. It proves the wiring
    /// (the presenter is started, and NOT gated on <c>IsLive</c>) without waiting out
    /// the real 5s DispatcherTimer — and because <c>Advance</c> only advances the
    /// cadence while the presenter is running, a credit coming out of here is proof
    /// that <c>Start()</c> happened at construction. Never call this from product code.</summary>
    internal void AdvanceBrandFlash(double seconds) => _brandFlash.Advance(seconds);

    /// <summary>Publish one credit frame to the preview pane, UI thread only (the
    /// presenter fires this from its own dispatcher tick, so the bitmap write is legal).
    /// Reuses one <see cref="System.Windows.Media.Imaging.WriteableBitmap"/> and
    /// overwrites its back buffer — a fresh 8MB bitmap per tick would churn the render
    /// cache for nothing.</summary>
    internal void PublishBrandFlashPreview(VideoFrame? frame)
    {
        if (frame == null)
        {
            if (_brandFlashBitmap != null) BrandFlashImageSource = null;
            return;
        }

        if (_brandFlashBitmap == null
            || _brandFlashBitmap.PixelWidth != frame.Width
            || _brandFlashBitmap.PixelHeight != frame.Height)
        {
            BrandFlashImageSource = new System.Windows.Media.Imaging.WriteableBitmap(
                frame.Width, frame.Height, 96, 96,
                System.Windows.Media.PixelFormats.Bgra32, null);
        }

        var target = _brandFlashBitmap!;
        target.WritePixels(
            new System.Windows.Int32Rect(0, 0, frame.Width, frame.Height),
            frame.BgraPixels, frame.Stride, 0);
        // The bitmap instance is unchanged, so the pane's Source binding still points
        // at it — nudge it so WPF re-reads the back buffer this tick.
        OnPropertyChanged(nameof(BrandFlashImageSource));
    }
}