deepdrft/DeepDrftPublic.Client/Pages/ReleaseDetailBase.cs

using DeepDrftModels.DTOs;
using DeepDrftPublic.Client.Services;
using DeepDrftPublic.Client.ViewModels;
using Microsoft.AspNetCore.Components;

namespace DeepDrftPublic.Client.Pages;

/// <summary>
/// Shared load + prerender-bridge logic for the single-release detail pages (Session, Mix).
/// Subclasses supply only their markup; this base loads the release through
/// <see cref="ReleaseDetailViewModel"/> and bridges the prerendered release across the prerender ->
/// WASM seam so the WASM pass does not re-fetch (see the MediumBrowseBase seam). The playable track is
/// re-resolved on a restore miss only.
/// </summary>
public abstract class ReleaseDetailBase : ComponentBase, IDisposable
{
    [Parameter] public string EntryKey { get; set; } = string.Empty;
    [Inject] public required ReleaseDetailViewModel ViewModel { get; set; }
    [Inject] public required PersistentComponentState PersistentState { get; set; }

    // Theater Mode (Phase 20). The page owns the content gate, so it must re-render when the flag flips
    // on the toggle. Property-injected; no constructor growth.
    [Inject] public required WaveformVisualizerControlState VisualizerControlState { get; set; }

    // Theater Mode is scoped to the currently-playing release (Phase 20 Wave 2 §3). The page observes
    // player state so the toggle availability and content gate re-evaluate live when playback starts,
    // stops, or moves to a different release. Cascaded by AudioPlayerProvider; no constructor growth.
    // The cascade is IsFixed, so the provider's own re-render does not reach this page — the page must
    // subscribe to StateChanged to re-render itself (same posture as AudioPlayerBar).
    [CascadingParameter] public IStreamingPlayerService? PlayerService { get; set; }

    private PersistingComponentStateSubscription _persistingSubscription;
    private IStreamingPlayerService? _subscribedPlayer;

    /// <summary>
    /// True when the currently-playing track belongs to this page's release. Theater Mode only applies
    /// to the playing release: a detail page whose release is not playing ignores the global flag and
    /// shows no toggle. Identity is the release <c>EntryKey</c> — the canonical public key the routes
    /// and <see cref="DeepDrftPublic.Client.Common.ReleaseRoutes"/> use.
    /// </summary>
    protected bool IsThisReleasePlaying =>
        PlayerService?.CurrentTrack?.Release?.EntryKey == EntryKey;

    /// <summary>
    /// True when this page's release content should be hidden for Theater Mode — only when Theater is on
    /// AND this release is the one playing. Drives the eased collapse of the hero/blurb regions.
    /// </summary>
    protected bool IsContentHidden => VisualizerControlState.TheaterMode && IsThisReleasePlaying;

    /// <summary>
    /// True when the Theater toggle should be offered on this page: a visualizer subsystem is on AND
    /// this page's release is the one playing.
    /// </summary>
    protected bool ShowTheaterToggle =>
        (VisualizerControlState.LavaEnabled || VisualizerControlState.WaveformEnabled) && IsThisReleasePlaying;

    // The release EntryKey the ViewModel currently holds. Tracks param-only navigations (e.g.
    // /mixes/{a} -> /mixes/{b}) which reuse this component instance and fire OnParametersSet
    // without re-running OnInitialized — without this, the page would keep the prior
    // release's track and Play would stream the wrong audio.
    private string? _loadedKey;
    private bool _loaded;

    // Distinct keys per medium so a Session restore never lands on a Mix page.
    protected abstract string PersistKey { get; }

    protected override void OnInitialized()
    {
        _persistingSubscription = PersistentState.RegisterOnPersisting(Persist);
        VisualizerControlState.Changed += OnVisualizerStateChanged;
    }

    private void OnVisualizerStateChanged() => InvokeAsync(StateHasChanged);

    private void OnPlayerStateChanged() => InvokeAsync(StateHasChanged);

    protected override async Task OnParametersSetAsync()
    {
        // The player cascade is IsFixed, so the provider's re-render does not reach this page; subscribe
        // to the StateChanged side-channel to re-render when playback moves between releases. Idempotent
        // (reference-guarded) and unsubscribed on dispose — same posture as AudioPlayerBar.
        if (PlayerService is not null && !ReferenceEquals(PlayerService, _subscribedPlayer))
        {
            if (_subscribedPlayer is not null)
                _subscribedPlayer.StateChanged -= OnPlayerStateChanged;

            PlayerService.StateChanged += OnPlayerStateChanged;
            _subscribedPlayer = PlayerService;
        }

        // Re-run whenever the route key changes. Component instances are reused across
        // same-template navigations, so the load decision must live here, not in
        // OnInitialized (which fires once per instance).
        if (_loaded && _loadedKey == EntryKey) return;

        // Capture the key synchronously before any await so that a re-entrant call
        // (rapid navigation or a re-render that changes EntryKey while Load is in flight)
        // sees the correct guard state. Without this, a second OnParametersSetAsync
        // for the same key would bypass the guard above and start a second Load,
        // causing two ViewModel.Load calls to race on the single scoped instance.
        _loadedKey = EntryKey;
        _loaded = true;

        // The bridged payload carries both the release and its resolved track so the interactive
        // pass renders identically without a second round-trip. Guard on the key: a payload for a
        // different release must not seed this page (stale-bridge bleed across navigation).
        if (PersistentState.TryTakeFromJson<BridgedDetail>(PersistKey, out var restored)
            && restored?.Release is not null
            && restored.Release.EntryKey == EntryKey)
        {
            ViewModel.Restore(restored.Release, restored.Track);
        }
        else
        {
            await ViewModel.Load(EntryKey);
        }
    }

    private Task Persist()
    {
        if (ViewModel.Release is not null)
            PersistentState.PersistAsJson(PersistKey, new BridgedDetail(ViewModel.Release, ViewModel.Track));
        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _persistingSubscription.Dispose();
        VisualizerControlState.Changed -= OnVisualizerStateChanged;
        if (_subscribedPlayer is not null)
        {
            _subscribedPlayer.StateChanged -= OnPlayerStateChanged;
            _subscribedPlayer = null;
        }
    }

    // JSON-serializable bridge payload. Round-trips through PersistentComponentState's serializer.
    protected sealed record BridgedDetail(ReleaseDto Release, TrackDto? Track);
}