ersatztv/ErsatzTV.Scanner/Core/Jellyfin/JellyfinMusicVideoLibraryScanner.cs

using ErsatzTV.Core;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Errors;
using ErsatzTV.Core.Extensions;
using ErsatzTV.Core.Interfaces.Jellyfin;
using ErsatzTV.Core.Interfaces.Repositories;
using ErsatzTV.Core.Jellyfin;
using ErsatzTV.Core.Metadata;
using ErsatzTV.Scanner.Core.Interfaces;
using ErsatzTV.Scanner.Core.Metadata;
using Microsoft.Extensions.Logging;

namespace ErsatzTV.Scanner.Core.Jellyfin;

public class JellyfinMusicVideoLibraryScanner : IJellyfinMusicVideoLibraryScanner
{
    private const string UnknownArtist = "Unknown Artist";

    private readonly IArtistRepository _artistRepository;
    private readonly IJellyfinApiClient _jellyfinApiClient;
    private readonly IJellyfinPathReplacementService _pathReplacementService;
    private readonly ILibraryRepository _libraryRepository;
    private readonly ILogger<JellyfinMusicVideoLibraryScanner> _logger;
    private readonly IMediaSourceRepository _mediaSourceRepository;
    private readonly IMetadataRepository _metadataRepository;
    private readonly IMusicVideoRepository _musicVideoRepository;
    private readonly IScannerProxy _scannerProxy;

    public JellyfinMusicVideoLibraryScanner(
        IScannerProxy scannerProxy,
        IJellyfinApiClient jellyfinApiClient,
        IJellyfinPathReplacementService pathReplacementService,
        IMediaSourceRepository mediaSourceRepository,
        IArtistRepository artistRepository,
        IMusicVideoRepository musicVideoRepository,
        ILibraryRepository libraryRepository,
        IMetadataRepository metadataRepository,
        ILogger<JellyfinMusicVideoLibraryScanner> logger)
    {
        _scannerProxy = scannerProxy;
        _jellyfinApiClient = jellyfinApiClient;
        _pathReplacementService = pathReplacementService;
        _mediaSourceRepository = mediaSourceRepository;
        _artistRepository = artistRepository;
        _musicVideoRepository = musicVideoRepository;
        _libraryRepository = libraryRepository;
        _metadataRepository = metadataRepository;
        _logger = logger;
    }

    public async Task<Either<BaseError, Unit>> ScanLibrary(
        JellyfinConnectionParameters connectionParameters,
        JellyfinLibrary library,
        bool deepScan,
        CancellationToken cancellationToken)
    {
        try
        {
            Option<LibraryPath> maybeLibraryPath = Optional(library.Paths).Flatten().HeadOrNone();
            return await maybeLibraryPath.Match(
                libraryPath => ScanLibrary(connectionParameters, library, libraryPath, cancellationToken),
                () => Task.FromResult<Either<BaseError, Unit>>(
                    BaseError.New($"Jellyfin library {library.Id} has no library path")));
        }
        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
        {
            return new ScanCanceled();
        }
    }

    private async Task<Either<BaseError, Unit>> ScanLibrary(
        JellyfinConnectionParameters connectionParameters,
        JellyfinLibrary library,
        LibraryPath libraryPath,
        CancellationToken cancellationToken)
    {
        List<JellyfinPathReplacement> pathReplacements =
            await _mediaSourceRepository.GetJellyfinPathReplacements(library.MediaSourceId);

        var processed = 0;
        var incomingPaths = new List<string>();
        await foreach ((MusicVideo incoming, int totalCount) in _jellyfinApiClient
                           .GetMusicVideoLibraryItems(
                               connectionParameters.Address,
                               connectionParameters.AuthorizationHeader,
                               library)
                           .WithCancellation(cancellationToken))
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return new ScanCanceled();
            }

            processed++;
            decimal percentCompletion = totalCount == 0 ? 1 : Math.Clamp((decimal)processed / totalCount, 0, 1);
            if (!await _scannerProxy.UpdateProgress(percentCompletion, cancellationToken))
            {
                return new ScanCanceled();
            }

            incomingPaths.Add(GetLocalPath(pathReplacements, incoming));

            Either<BaseError, MediaItemScanResult<MusicVideo>> maybeMusicVideo =
                await ProcessMusicVideo(library, libraryPath, pathReplacements, incoming, cancellationToken);

            foreach (BaseError error in maybeMusicVideo.LeftToSeq())
            {
                _logger.LogWarning("Error processing Jellyfin music video: {Error}", error.Value);
            }

            foreach (MediaItemScanResult<MusicVideo> result in maybeMusicVideo.RightToSeq()
                         .Filter(result => result.IsAdded || result.IsUpdated))
            {
                if (!await _scannerProxy.ReindexMediaItems([result.Item.Id], cancellationToken))
                {
                    _logger.LogWarning("Failed to reindex media items from scanner process");
                }
            }
        }

        await TrashMissingMusicVideos(library, libraryPath, incomingPaths, cancellationToken);

        return Unit.Default;
    }

    // ersatztv#494: remove music videos (and now-empty artists) that Jellyfin no longer reports.
    //
    // Identity is LIBRARY-SCOPED by (LibraryPathId, path): FindMusicVideoPaths and DeleteByPath both filter
    // LibraryPathId AND join the concrete MusicVideo table, so this can never touch a Movie/Show that shares
    // the same LibraryPath (a mixed library) — the cross-delete safety is a property of those queries, not of
    // the media kind. Unlike the MediaServer{Movie,Television,OtherVideo} base scanners, music videos carry no
    // server ItemId/Etag (there is no JellyfinMusicVideo entity), so we diff on the local path instead of the
    // server item id, and hard-delete rather than soft-trash (there is no per-item FileNotFound seam here).
    //
    // Known limitation: MusicVideoRepository.GetOrAdd dedups a path GLOBALLY (no LibraryPathId predicate), so a
    // file served by two libraries with overlapping local paths is a single row owned by whichever library
    // scanned it first. If that owning library later stops reporting the file while another library still
    // serves it, this sweep removes the shared row. A proper fix needs per-library music-video identity (a
    // JellyfinMusicVideo etag entity + migration) — the issue's deferred "option 2"; tracked as a follow-up.
    private async Task TrashMissingMusicVideos(
        JellyfinLibrary library,
        LibraryPath libraryPath,
        List<string> incomingPaths,
        CancellationToken cancellationToken)
    {
        var existingPaths = (await _musicVideoRepository.FindMusicVideoPaths(libraryPath)).ToList();

        // #477: refuse the sweep when a successful fetch returned zero items but rows exist locally — an empty
        // incoming set is indistinguishable from a transient error and would otherwise wipe the whole library.
        if (!MediaServerReconciliationGuard.ShouldFlagMissing(
                _logger,
                library.Name,
                incomingPaths.Count,
                existingPaths.Count))
        {
            return;
        }

        foreach (string path in existingPaths.Except(incomingPaths))
        {
            List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
            if (musicVideoIds.Count > 0 &&
                !await _scannerProxy.RemoveMediaItems(musicVideoIds.ToArray(), cancellationToken))
            {
                _logger.LogWarning("Failed to remove media items from scanner process");
            }
        }

        List<int> artistIds = await _artistRepository.DeleteEmptyArtists(libraryPath);
        if (artistIds.Count > 0 &&
            !await _scannerProxy.RemoveMediaItems(artistIds.ToArray(), cancellationToken))
        {
            _logger.LogWarning("Failed to remove empty artists from scanner process");
        }
    }

    private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> ProcessMusicVideo(
        JellyfinLibrary library,
        LibraryPath libraryPath,
        List<JellyfinPathReplacement> pathReplacements,
        MusicVideo incoming,
        CancellationToken cancellationToken)
    {
        string localPath = GetLocalPath(pathReplacements, incoming);
        string folder = Path.GetDirectoryName(localPath) ?? libraryPath.Path;
        Option<int> maybeParentFolder = await _libraryRepository.GetParentFolderId(libraryPath, folder, cancellationToken);
        LibraryFolder libraryFolder = await _libraryRepository.GetOrAddFolder(libraryPath, maybeParentFolder, folder);

        return await GetOrAddArtist(libraryPath, incoming)
            .BindT(artist => _musicVideoRepository.GetOrAdd(artist, libraryPath, libraryFolder, localPath))
            .BindT(result => UpdateMusicVideo(result, incoming, localPath, cancellationToken));
    }

    private string GetLocalPath(List<JellyfinPathReplacement> pathReplacements, MusicVideo musicVideo) =>
        _pathReplacementService.GetReplacementJellyfinPath(
            pathReplacements,
            musicVideo.GetHeadVersion().MediaFiles.Head().Path,
            false);

    private async Task<Either<BaseError, Artist>> GetOrAddArtist(LibraryPath libraryPath, MusicVideo musicVideo)
    {
        string artistName = musicVideo.MusicVideoMetadata
            .HeadOrNone()
            .Bind(metadata => Optional(metadata.Artists).Flatten().HeadOrNone())
            .Map(artist => artist.Name)
            .IfNone(UnknownArtist);

        var metadata = new ArtistMetadata
        {
            MetadataKind = MetadataKind.External,
            Title = artistName,
            SortTitle = SortTitle.GetSortTitle(artistName),
            DateAdded = DateTime.UtcNow,
            Genres = [],
            Styles = [],
            Moods = [],
            Artwork = [],
            Guids = [],
            Subtitles = []
        };

        Option<Artist> maybeArtist = await _artistRepository.GetArtistByMetadata(libraryPath.Id, metadata);
        foreach (Artist artist in maybeArtist)
        {
            return artist;
        }

        Either<BaseError, MediaItemScanResult<Artist>> result =
            await _artistRepository.AddArtist(libraryPath.Id, artistName, metadata);
        return result.Map(scanResult => scanResult.Item);
    }

    private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateMusicVideo(
        MediaItemScanResult<MusicVideo> result,
        MusicVideo incoming,
        string localPath,
        CancellationToken cancellationToken)
    {
        result.LocalPath = localPath;
        MusicVideoMetadata incomingMetadata = incoming.MusicVideoMetadata.Head();

        bool updated = await UpdateMetadata(result.Item, incomingMetadata);
        updated = await _metadataRepository.UpdateStatistics(result.Item, incoming.GetHeadVersion()) || updated;

        if (updated)
        {
            result.IsUpdated = true;
        }

        return result;
    }

    private async Task<bool> UpdateMetadata(MusicVideo musicVideo, MusicVideoMetadata incoming)
    {
        Option<MusicVideoMetadata> maybeExisting = Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone();
        foreach (MusicVideoMetadata existing in maybeExisting)
        {
            existing.Title = incoming.Title;
            existing.SortTitle = incoming.SortTitle;
            existing.Plot = incoming.Plot;
            existing.Year = incoming.Year;

            // ersatztv#177: Album/Track are scalars, so they must be copied here too — otherwise the
            // projection fix only ever reaches music videos ADDED after it, and an existing item whose
            // album/track is set (or corrected) in Jellyfin never picks it up. Same shape as the #497
            // collection bug below, one layer up.
            existing.Album = incoming.Album;
            existing.Track = incoming.Track;
            existing.ReleaseDate = incoming.ReleaseDate;
            existing.DateUpdated = DateTime.UtcNow;
            existing.MetadataKind = MetadataKind.External;

            bool updated = await _metadataRepository.Update(existing);

            // ersatztv#497: the scalar Update above marks only the metadata row Modified; it does NOT touch
            // child collections, and MusicVideoRepository.GetOrAdd loads them AsNoTracking — so tag/genre/studio/
            // artist edits made in Jellyfin never reached an EXISTING music video (only the Add path persisted
            // them). Reconcile the collections that BOTH the Add path persists AND GetOrAdd eager-loads:
            // Genres, Tags, Studios, Artists. (Guids are add-persisted but not eager-loaded here — reconciling
            // them would see an empty `existing` and duplicate-insert every scan; Directors are eager-loaded
            // but not add-persisted for music videos — both are deliberately out of scope.) Mirrors the
            // remove-stale + add-new idiom PlexMovieLibraryScanner.UpdateMetadata uses.
            updated = await ReconcileGenres(existing, incoming) || updated;
            updated = await ReconcileTags(existing, incoming) || updated;
            updated = await ReconcileStudios(existing, incoming) || updated;
            updated = await ReconcileArtists(existing, incoming) || updated;

            return updated;
        }

        incoming.MusicVideoId = musicVideo.Id;
        musicVideo.MusicVideoMetadata = [incoming];
        return await _metadataRepository.Add(incoming);
    }

    private async Task<bool> ReconcileGenres(MusicVideoMetadata existing, MusicVideoMetadata incoming)
    {
        existing.Genres ??= [];
        List<Genre> incomingGenres = incoming.Genres ?? [];
        var updated = false;

        foreach (Genre genre in existing.Genres.Filter(g => incomingGenres.All(g2 => g2.Name != g.Name)).ToList())
        {
            existing.Genres.Remove(genre);
            updated = await _metadataRepository.RemoveGenre(genre) || updated;
        }

        foreach (Genre genre in incomingGenres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name)).ToList())
        {
            existing.Genres.Add(genre);
            updated = await _musicVideoRepository.AddGenre(existing, genre) || updated;
        }

        return updated;
    }

    private async Task<bool> ReconcileTags(MusicVideoMetadata existing, MusicVideoMetadata incoming)
    {
        existing.Tags ??= [];
        List<Tag> incomingTags = incoming.Tags ?? [];
        var updated = false;

        foreach (Tag tag in existing.Tags.Filter(t => incomingTags.All(t2 => t2.Name != t.Name)).ToList())
        {
            existing.Tags.Remove(tag);
            updated = await _metadataRepository.RemoveTag(tag) || updated;
        }

        foreach (Tag tag in incomingTags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name)).ToList())
        {
            existing.Tags.Add(tag);
            updated = await _musicVideoRepository.AddTag(existing, tag) || updated;
        }

        return updated;
    }

    private async Task<bool> ReconcileStudios(MusicVideoMetadata existing, MusicVideoMetadata incoming)
    {
        existing.Studios ??= [];
        List<Studio> incomingStudios = incoming.Studios ?? [];
        var updated = false;

        foreach (Studio studio in existing.Studios.Filter(s => incomingStudios.All(s2 => s2.Name != s.Name)).ToList())
        {
            existing.Studios.Remove(studio);
            updated = await _metadataRepository.RemoveStudio(studio) || updated;
        }

        foreach (Studio studio in incomingStudios.Filter(s => existing.Studios.All(s2 => s2.Name != s.Name)).ToList())
        {
            existing.Studios.Add(studio);
            updated = await _musicVideoRepository.AddStudio(existing, studio) || updated;
        }

        return updated;
    }

    private async Task<bool> ReconcileArtists(MusicVideoMetadata existing, MusicVideoMetadata incoming)
    {
        existing.Artists ??= [];
        List<MusicVideoArtist> incomingArtists = incoming.Artists ?? [];
        var updated = false;

        foreach (MusicVideoArtist artist in existing.Artists
                     .Filter(a => incomingArtists.All(a2 => a2.Name != a.Name)).ToList())
        {
            existing.Artists.Remove(artist);
            updated = await _musicVideoRepository.RemoveArtist(artist) || updated;
        }

        foreach (MusicVideoArtist artist in incomingArtists
                     .Filter(a => existing.Artists.All(a2 => a2.Name != a.Name)).ToList())
        {
            existing.Artists.Add(artist);
            updated = await _musicVideoRepository.AddArtist(existing, artist) || updated;
        }

        return updated;
    }
}