deepdrft/DeepDrftManager/Components/Pages/Tracks/BatchUpload.razor

@page "/tracks/upload"
@using System.Security.Claims
@using DeepDrftManager.Services
@using DeepDrftModels.Enums
@using Microsoft.AspNetCore.Components.Forms
@attribute [Authorize]

@inject ICmsTrackService CmsTrackService
@inject ICmsReleaseService CmsReleaseService
@inject AuthenticationStateProvider AuthStateProvider
@inject NavigationManager Navigation
@inject ISnackbar Snackbar
@inject ILogger<BatchUpload> Logger

<PageTitle>Upload Release — Deep DRFT Management</PageTitle>

<MudContainer MaxWidth="MaxWidth.Large" Class="mt-8">
    <MudText Typo="Typo.h4" GutterBottom="true">Upload Release</MudText>

    <AlbumHeaderFields @bind-AlbumName="_albumName"
                       @bind-Artist="_artist"
                       @bind-Genre="_genre"
                       @bind-Description="_description"
                       @bind-ReleaseDate="_releaseDate"
                       @bind-ReleaseType="_releaseType"
                       Medium="_medium"
                       MediumChanged="OnMediumChanged"
                       @bind-SelectedImageFile="_selectedImageFile"
                       @bind-HeroImageFile="_heroImageFile"
                       AllowHeroUpload="true"
                       Disabled="_uploading" />

    @if (_medium == ReleaseMedium.Cut)
    {
        <MudGrid>
            <MudItem xs="12" md="5">
                <BatchTrackList Tracks="_tracks"
                                @bind-SelectedIndex="_selectedIndex"
                                Disabled="_uploading"
                                OnWavFilesSelected="HandleWavFilesSelected"
                                OnMoveUp="MoveUp"
                                OnMoveDown="MoveDown"
                                OnRemove="RemoveRow" />
            </MudItem>

            <MudItem xs="12" md="7">
                <MudPaper Class="pa-4" Elevation="2">
                    <BatchTrackDetail SelectedTrack="@(_selectedIndex >= 0 && _tracks.Count > 0 ? _tracks[_selectedIndex] : null)"
                                      Disabled="_uploading"
                                      TrackNameChanged="@(name => { if (_selectedIndex >= 0) { _tracks[_selectedIndex].TrackName = name; } })" />
                </MudPaper>
            </MudItem>
        </MudGrid>
    }
    else
    {
        @* Session/Mix are single-track releases — no multi-track master list. A single WAV slot. *@
        <MudPaper Class="pa-4" Elevation="2">
            <MudStack Spacing="3">
                <MudText Typo="Typo.subtitle1">Track</MudText>
                <InputFile OnChange="HandleSingleWavSelected" accept=".wav,audio/wav,audio/x-wav" disabled="@_uploading" />
                @if (_tracks.Count > 0)
                {
                    @* Track name is derived from the Release Name for Session/Mix — no separate input. *@
                    <MudText Typo="Typo.caption">Selected: @(_tracks[0].WavFile?.Name ?? "—")</MudText>
                    @if (_tracks[0].Status == BatchRowStatus.Uploading)
                    {
                        <MudProgressLinear Color="Color.Info"
                                           Value="@_tracks[0].UploadPercent"
                                           aria-label="Uploading track" />
                    }
                }
            </MudStack>
        </MudPaper>
    }

    @if (!string.IsNullOrEmpty(_errorMessage))
    {
        <MudAlert Severity="Severity.Error" Class="mt-4">@_errorMessage</MudAlert>
    }

    @if (!string.IsNullOrEmpty(_warningMessage))
    {
        <MudAlert Severity="Severity.Warning" Class="mt-4">@_warningMessage</MudAlert>
    }

    <MudStack Row="true" Justify="Justify.FlexEnd" Spacing="2" Class="mt-4">
        <MudButton Variant="Variant.Text"
                   OnClick="@(() => Navigation.NavigateTo("/releases"))"
                   Disabled="_uploading">
            Cancel
        </MudButton>
        <MudButton Variant="Variant.Filled"
                   Color="Color.Primary"
                   OnClick="SubmitAsync"
                   Disabled="@(_uploading || _tracks.Count == 0)">
            @if (_uploading)
            {
                <MudProgressCircular Indeterminate="true" Size="Size.Small" Class="mr-2" />
                <text>Uploading @_uploadedCount / @_tracks.Count…</text>
            }
            else
            {
                <text>Upload Release</text>
            }
        </MudButton>
    </MudStack>
</MudContainer>

@code {
    // ~1.86 GB ceiling matches DeepDrftAPI's per-request limit on api/track/upload; the
    // streaming path means the limit caps the request, not in-memory buffering.
    private const long MaxUploadBytes = 2_000_000_000L;

    private List<BatchRowModel> _tracks = new();
    private int _selectedIndex = -1;
    private bool _uploading;
    private int _uploadedCount;
    private string? _errorMessage;
    // Separate from _errorMessage: a soft non-blocking nudge (Severity.Warning), not a hard failure.
    private string? _warningMessage;

    private IBrowserFile? _selectedImageFile;
    private string? _imagePath;

    // Session-only: the hero image is resource-addressed and cannot be uploaded until the release
    // exists, so it is held here and POSTed to api/release/{id}/session/hero-image after create.
    private IBrowserFile? _heroImageFile;
    // Set true once the admin has acknowledged the missing-hero warning, so a second submit proceeds.
    private bool _heroWarningAcknowledged;

    // Captured once at component initialization on the live interactive circuit, while the token
    // is known-good, so a mid-session token expiry at submit time cannot discard a long-composed
    // release. Only assigned when the id parses successfully.
    private long? _createdByUserId;

    private string _albumName = string.Empty;
    private string _artist = string.Empty;
    private string _genre = string.Empty;
    private string _description = string.Empty;
    private string _releaseDate = string.Empty;
    private ReleaseType _releaseType = ReleaseType.Single;
    private ReleaseMedium _medium = ReleaseMedium.Cut;

    // Optional pre-select from the Add-Track buttons (§8.E): /tracks/upload?medium=session lands the
    // form already in Session mode. A seed only — the medium selector stays user-changeable after load.
    // Unrecognised/absent values fall through to the Cut default (same defensive posture as the API's
    // TrackController.UploadTrack medium parse).
    [SupplyParameterFromQuery(Name = "medium")] public string? MediumParam { get; set; }

    protected override void OnInitialized()
    {
        // Seed the medium from the query param so a pre-selected upload form (e.g. the Sessions tab's
        // Add Track) lands already showing that medium's conditional fields. Goes through OnMediumChanged
        // so the single-track collapse runs identically to a user selector change.
        if (!string.IsNullOrWhiteSpace(MediumParam)
            && Enum.TryParse<ReleaseMedium>(MediumParam, ignoreCase: true, out var medium)
            && Enum.IsDefined(medium))
        {
            OnMediumChanged(medium);
        }
    }

    protected override async Task OnInitializedAsync()
    {
        // Capture the user id once at load, while the token is known-good. The CMS host runs with
        // prerender: false (InteractiveServer), so this is the single init pass — auth state is
        // fully available. The page is [Authorize]-gated, so the parse should always succeed.
        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
        var userIdValue = authState.User.FindFirstValue(ClaimTypes.NameIdentifier);
        if (long.TryParse(userIdValue, out var userId))
        {
            _createdByUserId = userId;
        }
    }

    // Switching to a single-track medium collapses any multi-track selection to the first row so the
    // single-track invariant holds before submit. The predicate reads the same MediumRules cardinality
    // declaration the upload service enforces, so the form and the domain cannot drift.
    private void OnMediumChanged(ReleaseMedium medium)
    {
        _medium = medium;
        if (MediumRules.CardinalityOf(medium).IsSingleTrack && _tracks.Count > 1)
        {
            _tracks.RemoveRange(1, _tracks.Count - 1);
            _selectedIndex = _tracks.Count > 0 ? 0 : -1;
        }
    }

    // Single-track WAV picker for Session/Mix: replaces the one row rather than appending.
    private void HandleSingleWavSelected(InputFileChangeEventArgs e)
    {
        _errorMessage = null;
        var file = e.File;
        if (!file.Name.EndsWith(".wav", StringComparison.OrdinalIgnoreCase))
        {
            Snackbar.Add($"'{file.Name}' is not a .wav file.", Severity.Warning);
            return;
        }

        _tracks.Clear();
        _tracks.Add(new BatchRowModel
        {
            WavFile = file,
            TrackName = Path.GetFileNameWithoutExtension(file.Name)
        });
        _selectedIndex = 0;
    }

    private void HandleWavFilesSelected(IReadOnlyList<IBrowserFile> files)
    {
        _errorMessage = null;
        foreach (var file in files)
        {
            if (!file.Name.EndsWith(".wav", StringComparison.OrdinalIgnoreCase))
            {
                Snackbar.Add($"Skipped '{file.Name}' — not a .wav file.", Severity.Warning);
                continue;
            }

            _tracks.Add(new BatchRowModel
            {
                WavFile = file,
                TrackName = Path.GetFileNameWithoutExtension(file.Name)
            });
        }

        if (_selectedIndex < 0 && _tracks.Count > 0)
        {
            _selectedIndex = 0;
        }
    }

    private void MoveUp(int i)
    {
        if (i == 0) return;
        (_tracks[i], _tracks[i - 1]) = (_tracks[i - 1], _tracks[i]);
        if (_selectedIndex == i) _selectedIndex = i - 1;
        else if (_selectedIndex == i - 1) _selectedIndex = i;
    }

    private void MoveDown(int i)
    {
        if (i == _tracks.Count - 1) return;
        (_tracks[i], _tracks[i + 1]) = (_tracks[i + 1], _tracks[i]);
        if (_selectedIndex == i) _selectedIndex = i + 1;
        else if (_selectedIndex == i + 1) _selectedIndex = i;
    }

    private void RemoveRow(int i)
    {
        _tracks.RemoveAt(i);
        if (i < _selectedIndex) _selectedIndex--;
        if (_selectedIndex >= _tracks.Count) _selectedIndex = _tracks.Count - 1;
    }

    private async Task SubmitAsync()
    {
        _errorMessage = null;
        _warningMessage = null;

        if (string.IsNullOrWhiteSpace(_albumName))
        {
            _errorMessage = "Release Name is required.";
            return;
        }

        if (string.IsNullOrWhiteSpace(_artist))
        {
            _errorMessage = "Artist is required.";
            return;
        }

        if (_tracks.Count == 0)
        {
            _errorMessage = "Add at least one track.";
            return;
        }

        if (!string.IsNullOrWhiteSpace(_releaseDate)
            && !DateOnly.TryParseExact(_releaseDate, "yyyy-MM-dd", out _))
        {
            _errorMessage = "Release Date must be in YYYY-MM-DD format.";
            return;
        }

        foreach (var t in _tracks)
        {
            if (t.WavFile is null)
            {
                _errorMessage = $"'{t.TrackName}' has no WAV file selected.";
                return;
            }
        }

        if (_createdByUserId is not long createdByUserId)
        {
            // _createdByUserId is set at component initialization from the authenticated principal.
            // A null here means the id was unavailable even at load — a genuine configuration bug,
            // since the page is [Authorize]-gated.
            Logger.LogError("User id was not captured at initialization — NameIdentifier claim missing or unparseable.");
            _errorMessage = "Your session is missing a valid identifier. Please sign in again.";
            return;
        }

        // A Session's hero is its primary visual identity on the public detail page. It is optional —
        // a Session can be authored without one and set later from the Sessions browser — but a missing
        // hero is usually an oversight, so warn (do not block). The first submit without a hero shows the
        // warning and primes acknowledgment; a second submit proceeds.
        if (_medium == ReleaseMedium.Session && _heroImageFile is null && !_heroWarningAcknowledged)
        {
            _heroWarningAcknowledged = true;
            _warningMessage = "No hero image selected. A Session usually needs one — you can add it now, "
                + "or submit again to create the Session without it (set the hero later from the Sessions browser).";
            return;
        }

        // Pre-flight duplicate guard (primary block): the upload form creates new releases only, so a
        // (title, artist) that already exists in the catalogue is refused BEFORE any bytes transfer —
        // the admin is not surprised at the end of a long upload. The server backstops this on the
        // create path, but checking here keeps the failure fast and visible. The values passed match
        // exactly what the upload sends (untrimmed _albumName/_artist) so the pre-flight and the server
        // agree on the match. A check failure (API unreachable) blocks rather than proceeding blind.
        var duplicateCheck = await CmsTrackService.GetExistingReleaseAsync(_albumName, _artist);
        if (!duplicateCheck.Success)
        {
            var checkError = duplicateCheck.Messages.FirstOrDefault()?.Message ?? "Unknown error";
            _errorMessage = $"Could not verify the release name: {checkError}";
            Snackbar.Add(_errorMessage, Severity.Error);
            return;
        }

        if (duplicateCheck.Value is { } existing)
        {
            _errorMessage = $"A release titled '{existing.Title}' by {existing.Artist} already exists. "
                + "The upload form creates new releases only — use the edit tools to change an existing one.";
            Snackbar.Add(_errorMessage, Severity.Error);
            return;
        }

        // For single-track media (Session/Mix) the track name is derived from the Release Name —
        // no separate Track Name input is shown. Sync here so the stored name always matches.
        if (MediumRules.CardinalityOf(_medium).IsSingleTrack && _tracks.Count > 0)
        {
            _tracks[0].TrackName = _albumName;
        }

        _imagePath = null; // Clear any stale uploaded path from a prior partial attempt.
        _uploading = true;
        _uploadedCount = 0;

        try
        {
            // Upload any selected cover art once; abort the submit if it fails so we never
            // create tracks expecting an image that was never stored in the vault.
            if (_selectedImageFile is { } imgFile)
            {
                await using var imgStream = imgFile.OpenReadStream(maxAllowedSize: 50_000_000);
                var imgResult = await CmsTrackService.UploadImageAsync(imgStream, imgFile.Name, imgFile.ContentType);
                if (!imgResult.Success)
                {
                    var imgError = imgResult.Messages.FirstOrDefault()?.Message ?? "Unknown error";
                    _errorMessage = $"Image upload failed: {imgError}";
                    return;
                }
                _imagePath = imgResult.Value;
            }

            int succeeded = 0, failed = 0;
            // Within-batch attach: row 1 creates the release (no releaseId → CREATE path); once it
            // succeeds we carry its ReleaseId into rows 2..N so they ATTACH to the just-created release
            // rather than tripping the server's pre-existing-duplicate block. Only a multi-track Cut
            // reaches row 2 (single-track media collapse to one row).
            long? batchReleaseId = null;
            for (int i = 0; i < _tracks.Count; i++)
            {
                var row = _tracks[i];
                var trackNumber = i + 1; // 1-based ordinal from list position

                row.Status = BatchRowStatus.Uploading;
                StateHasChanged();

                row.UploadedBytes = 0;
                row.TotalBytes = row.WavFile!.Size;

                try
                {
                    // OpenReadStream streams chunks from the browser via the SignalR circuit; the
                    // service wraps it in ProgressStreamContent so the whole file is never materialised
                    // in memory before DeepDrftAPI receives it, and reports bytes-on-the-wire back here.
                    await using var wavStream = row.WavFile.OpenReadStream(MaxUploadBytes);

                    // Progress ticks fire ~once per 80 KB; re-render only when the whole-percent changes
                    // so a half-gig upload paints ~100 frames, not thousands. Progress<T> marshals the
                    // callback onto the component's renderer dispatcher, so StateHasChanged is safe here.
                    var lastPercent = -1;
                    var progress = new Progress<long>(written =>
                    {
                        row.UploadedBytes = written;
                        if (row.UploadPercent != lastPercent)
                        {
                            lastPercent = row.UploadPercent;
                            StateHasChanged();
                        }
                    });

                    var result = await CmsTrackService.UploadTrackAsync(
                        wavStream,
                        row.WavFile.Size,
                        row.WavFile.Name,
                        row.WavFile.ContentType,
                        row.TrackName,
                        _artist,
                        string.IsNullOrWhiteSpace(_albumName) ? null : _albumName,
                        string.IsNullOrWhiteSpace(_genre) ? null : _genre,
                        string.IsNullOrWhiteSpace(_description) ? null : _description,
                        string.IsNullOrWhiteSpace(_releaseDate) ? null : _releaseDate,
                        row.WavFile.Name,
                        createdByUserId,
                        _releaseType,
                        trackNumber,
                        _medium,
                        batchReleaseId,
                        progress);

                    if (!result.Success || result.Value is null)
                    {
                        var error = result.Messages.FirstOrDefault()?.Message ?? "Unknown error";
                        row.Status = BatchRowStatus.Failed;
                        row.ErrorMessage = error;
                        failed++;
                        Logger.LogWarning("Batch upload: track '{TrackName}' failed: {Error}", row.TrackName, error);
                    }
                    else
                    {
                        // Capture the release id created by the first successful row so subsequent rows
                        // attach to it (the within-batch multi-track Cut path). Only set once — later
                        // rows must not overwrite it. A null ReleaseId here (loose track) leaves it null,
                        // which is correct: a release-less upload has no within-batch release to attach to.
                        if (batchReleaseId is null && result.Value.ReleaseId is { } createdReleaseId)
                        {
                            batchReleaseId = createdReleaseId;
                        }

                        // The upload endpoint does not accept an imagePath, so link the cover art with
                        // a follow-up metadata update — same two-step pattern BatchEdit uses.
                        if (_imagePath is { } imgPath)
                        {
                            var linkResult = await CmsTrackService.UpdateAsync(
                                result.Value.Id,
                                row.TrackName,
                                _artist,
                                string.IsNullOrWhiteSpace(_albumName) ? null : _albumName,
                                string.IsNullOrWhiteSpace(_genre) ? null : _genre,
                                string.IsNullOrWhiteSpace(_description) ? null : _description,
                                string.IsNullOrWhiteSpace(_releaseDate) ? null : (DateOnly?)DateOnly.ParseExact(_releaseDate, "yyyy-MM-dd"),
                                imgPath,
                                _releaseType,
                                _medium,
                                trackNumber);

                            if (!linkResult.Success)
                            {
                                // Non-blocking: track is persisted; cover art can be re-linked by editing.
                                Logger.LogWarning("Batch upload: cover art link failed for '{TrackName}' (id={Id}) — track uploaded but image unlinked",
                                    row.TrackName, result.Value.Id);
                            }
                        }

                        // Session hero image is resource-addressed, so it is uploaded here — after the
                        // release exists and we have its id — within the same submit gesture. Non-blocking:
                        // the Session is persisted; a failed hero upload is recoverable from the Sessions
                        // browser's per-row Set/Replace hero action.
                        if (_medium == ReleaseMedium.Session
                            && _heroImageFile is { } heroFile
                            && result.Value.ReleaseId is { } sessionReleaseId)
                        {
                            try
                            {
                                await using var heroStream = heroFile.OpenReadStream(maxAllowedSize: 50_000_000);
                                var heroResult = await CmsReleaseService.UploadSessionHeroImageAsync(
                                    sessionReleaseId, heroStream, heroFile.Name, heroFile.ContentType);
                                if (!heroResult.Success)
                                {
                                    var heroError = heroResult.Messages.FirstOrDefault()?.Message ?? "Unknown error";
                                    Logger.LogWarning("Batch upload: hero image upload failed for release {ReleaseId} ('{TrackName}'): {Error}",
                                        sessionReleaseId, row.TrackName, heroError);
                                    Snackbar.Add("Session uploaded, but the hero image failed. Set it from the Sessions browser.", Severity.Warning);
                                }
                            }
                            catch (Exception heroEx)
                            {
                                Logger.LogError(heroEx, "Batch upload: exception uploading hero image for release {ReleaseId}", sessionReleaseId);
                                Snackbar.Add("Session uploaded, but the hero image failed. Set it from the Sessions browser.", Severity.Warning);
                            }
                        }
                        else if (_medium == ReleaseMedium.Session && _heroImageFile is not null)
                        {
                            // ReleaseId was null on a Session track result — internal inconsistency.
                            // Hero file is held but cannot be uploaded without a release id; log and
                            // surface so the admin can set it from the Sessions browser.
                            Logger.LogWarning("Batch upload: Session track '{TrackName}' (id={Id}) has no ReleaseId — hero image dropped",
                                row.TrackName, result.Value.Id);
                            Snackbar.Add("Session uploaded, but the hero image could not be linked (no release id). Set it from the Sessions browser.", Severity.Warning);
                        }

                        // Mix uploads fire the server-side high-res waveform trigger (§3.4). The CMS
                        // computes nothing — the API derives the datum from the audio it just stored.
                        // Non-blocking: the track is persisted; a failed trigger is recoverable from
                        // the Mixes browser's per-row Generate action.
                        if (_medium == ReleaseMedium.Mix && result.Value.ReleaseId is { } mixReleaseId)
                        {
                            var waveformResult = await CmsReleaseService.GenerateMixWaveformAsync(mixReleaseId);
                            if (!waveformResult.Success)
                            {
                                Logger.LogWarning("Batch upload: mix waveform trigger failed for release {ReleaseId} ('{TrackName}')",
                                    mixReleaseId, row.TrackName);
                                Snackbar.Add("Mix uploaded, but waveform generation failed. Retry from the Mixes browser.", Severity.Warning);
                            }
                        }

                        row.Status = BatchRowStatus.Done;
                        succeeded++;
                    }
                }
                catch (Exception ex)
                {
                    Logger.LogError(ex, "Batch upload: exception uploading '{TrackName}'", row.TrackName);
                    row.Status = BatchRowStatus.Failed;
                    row.ErrorMessage = "Upload failed — please try again.";
                    failed++;
                }

                _uploadedCount++;
                StateHasChanged();
            }

            if (failed == 0)
            {
                Snackbar.Add($"Uploaded {succeeded} track(s).", Severity.Success);
                Navigation.NavigateTo("/releases");
            }
            else
            {
                // Surface the actual reason, not just counts — a server rejection (duplicate, cardinality)
                // relays a human-readable message via row.ErrorMessage. Show the first failure's reason so
                // the admin sees WHY without scanning the rows; the per-row errors remain as detail.
                var firstError = _tracks.FirstOrDefault(t => t.Status == BatchRowStatus.Failed)?.ErrorMessage;
                var reason = string.IsNullOrWhiteSpace(firstError) ? "review errors below" : firstError;
                _errorMessage = succeeded == 0 ? reason : $"{succeeded} uploaded; {failed} failed: {reason}";
                Snackbar.Add($"Uploaded {succeeded} track(s); {failed} failed — {reason}", Severity.Warning);
                // Stay on page so the admin can see the failed rows.
            }
        }
        finally
        {
            _uploading = false;
            StateHasChanged();
        }
    }
}