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

namespace DeepDrftPublic.Client.Pages;

/// <summary>
/// Load + prerender-bridge logic for the Cut album-detail page (/cuts/{entryKey}). Mirrors
/// <see cref="ReleaseDetailBase"/>'s discipline (id-addressed load in OnParametersSetAsync,
/// PersistentComponentState bridge guarded on id) but carries the multi-track payload (release +
/// ordered track list) the Cut page needs. Kept separate from the single-track base so neither
/// grows a medium conditional — the two release shapes are genuinely different (one track vs many).
/// </summary>
public abstract class CutDetailBase : ComponentBase, IDisposable
{
    private const string PersistKey = "cut-detail";

    [Parameter] public string EntryKey { get; set; } = string.Empty;
    [Inject] public required CutDetailViewModel ViewModel { get; set; }
    [Inject] public required PersistentComponentState PersistentState { get; set; }

    private PersistingComponentStateSubscription _persistingSubscription;

    // The release EntryKey the ViewModel currently holds — tracks param-only navigations (e.g.
    // /cuts/{a} -> /cuts/{b}) which reuse this component instance and fire OnParametersSet without
    // re-running OnInitialized. Without it the page would keep the prior album's tracks.
    private string? _loadedKey;
    private bool _loaded;

    protected override void OnInitialized()
        => _persistingSubscription = PersistentState.RegisterOnPersisting(Persist);

    protected override async Task OnParametersSetAsync()
    {
        if (_loaded && _loadedKey == EntryKey) return;

        // Capture the key synchronously before any await so a re-entrant call (rapid navigation or a
        // re-render that changes EntryKey while Load is in flight) sees the correct guard state.
        _loadedKey = EntryKey;
        _loaded = true;

        // The bridged payload carries the release and its ordered tracks 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<BridgedCut>(PersistKey, out var restored)
            && restored?.Release is not null
            && restored.Release.EntryKey == EntryKey)
        {
            ViewModel.Restore(restored.Release, restored.Tracks);
        }
        else
        {
            await ViewModel.Load(EntryKey);
        }
    }

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

    public void Dispose() => _persistingSubscription.Dispose();

    // JSON-serializable bridge payload. Round-trips through PersistentComponentState's serializer.
    protected sealed record BridgedCut(ReleaseDto Release, IReadOnlyList<TrackDto> Tracks);
}