fix: add debouncing updates to artist metadata scan to prevent lag

Author: Anthonyy232

src/Nagi.Core/Services/Abstractions/ILibraryScanner.cs

@@ -9,6 +9,7 @@ namespace Nagi.Core.Services.Abstractions;
 public interface ILibraryScanner
 {
     event EventHandler<ArtistMetadataUpdatedEventArgs>? ArtistMetadataUpdated;
+    event EventHandler<IEnumerable<ArtistMetadataUpdatedEventArgs>>? ArtistMetadataBatchUpdated;
     event EventHandler<bool>? ScanCompleted;
     event EventHandler<LibraryContentChangedEventArgs>? LibraryContentChanged;
 

src/Nagi.Core/Services/Implementations/LibraryService.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Threading.Channels;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
@@ -114,6 +115,9 @@ public LibraryService(
     /// </summary>
     public event EventHandler<ArtistMetadataUpdatedEventArgs>? ArtistMetadataUpdated;
 
+    /// <inheritdoc />
+    public event EventHandler<IEnumerable<ArtistMetadataUpdatedEventArgs>>? ArtistMetadataBatchUpdated;
+
     /// <inheritdoc />
     public event EventHandler<PlaylistUpdatedEventArgs>? PlaylistUpdated;
 
@@ -931,7 +935,8 @@ public async Task<bool> RefreshAllFoldersAsync(bool forceFullScan, IProgress<Sca
         {
             try
             {
-                await FetchAndUpdateArtistFromRemoteAsync(context, artist, cancellationToken).ConfigureAwait(false);
+                // For single artist details, we want immediate save and events
+                await FetchAndUpdateArtistFromRemoteAsync(context, artist, cancellationToken, saveChanges: true, suppressEvents: false).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -990,16 +995,40 @@ public async Task StartArtistMetadataBackgroundFetchAsync()
                     using var scope = _serviceScopeFactory.CreateScope();
                     var scopedContextFactory =
                         scope.ServiceProvider.GetRequiredService<IDbContextFactory<MusicDbContext>>();
+                    
+                    // We need a context to fetch and update entities
                     await using var batchContext = await scopedContextFactory.CreateDbContextAsync().ConfigureAwait(false);
 
                     var artistsInBatch = await batchContext.Artists.Where(a => artistIdsToUpdate.Contains(a.Id))
                         .ToListAsync(token).ConfigureAwait(false);
+                        
+                    var pendingUpdates = new List<ArtistMetadataUpdatedEventArgs>();
+                    var stopwatch = Stopwatch.StartNew();
+
                     foreach (var artist in artistsInBatch)
                     {
                         if (token.IsCancellationRequested) break;
                         try
                         {
-                            await FetchAndUpdateArtistFromRemoteAsync(batchContext, artist, token).ConfigureAwait(false);
+                            // Pass saveChanges: false and suppressEvents: true to batch operations
+                            var (updated, newImagePath) = await FetchAndUpdateArtistFromRemoteAsync(
+                                batchContext, artist, token, saveChanges: false, suppressEvents: true).ConfigureAwait(false);
+                                
+                            if (updated)
+                            {
+                                pendingUpdates.Add(new ArtistMetadataUpdatedEventArgs(artist.Id, newImagePath));
+                            }
+                            
+                            // Hybrid Flush Check: 10 items or 5 seconds
+                            if (pendingUpdates.Count >= 10 || (pendingUpdates.Count > 0 && stopwatch.Elapsed.TotalSeconds >= 5))
+                            {
+                                await batchContext.SaveChangesAsync(token).ConfigureAwait(false);
+                                _logger.LogInformation("Saved partial batch of {Count} artists metadata (Time: {Elapsed}s).", pendingUpdates.Count, stopwatch.Elapsed.TotalSeconds.ToString("F1"));
+                                
+                                ArtistMetadataBatchUpdated?.Invoke(this, pendingUpdates.ToList());
+                                pendingUpdates.Clear();
+                                stopwatch.Restart();
+                            }
                         }
                         catch (DbUpdateConcurrencyException)
                         {
@@ -1012,6 +1041,18 @@ public async Task StartArtistMetadataBackgroundFetchAsync()
                             _logger.LogError(ex, "Failed to update artist {ArtistId} in background.", artist.Id);
                         }
                     }
+                    
+                    if (token.IsCancellationRequested) break;
+
+                    // Final flush for remaining items in the batch
+                    if (pendingUpdates.Count > 0)
+                    {
+                        await batchContext.SaveChangesAsync(token).ConfigureAwait(false);
+                        _logger.LogInformation("Saved final batch of {Count} artists metadata.", pendingUpdates.Count);
+                        
+                        // Fire batch event
+                        ArtistMetadataBatchUpdated?.Invoke(this, pendingUpdates);
+                    }
                 }
             }
             catch (OperationCanceledException)
@@ -4195,7 +4236,15 @@ public async Task<bool> RemoveArtistImageAsync(Guid artistId)
         }
     }
 
-    private async Task FetchAndUpdateArtistFromRemoteAsync(MusicDbContext context, Artist artist, CancellationToken cancellationToken = default)
+    /// <summary>
+    ///     Fetches metadata from remote sources and updates availability status.
+    /// </summary>
+    private async Task<(bool Updated, string? NewImagePath)> FetchAndUpdateArtistFromRemoteAsync(
+        MusicDbContext context, 
+        Artist artist, 
+        CancellationToken cancellationToken = default,
+        bool saveChanges = true,
+        bool suppressEvents = false)
     {
         var wasMetadataFoundAndUpdated = false;
 
@@ -4205,7 +4254,7 @@ private async Task FetchAndUpdateArtistFromRemoteAsync(MusicDbContext context, A
         if (enabledProviders.Count == 0)
         {
             _logger.LogDebug("No metadata providers enabled. Skipping remote fetch for artist '{ArtistName}'.", artist.Name);
-            return;
+            return (false, artist.LocalImageCachePath);
         }
 
         _logger.LogDebug("Using metadata providers for '{ArtistName}': {Providers}", 
@@ -4355,11 +4404,17 @@ private async Task FetchAndUpdateArtistFromRemoteAsync(MusicDbContext context, A
         }
 
         artist.MetadataLastCheckedUtc = DateTime.UtcNow;
-        await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+        if (saveChanges)
+        {
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        if (!suppressEvents && wasMetadataFoundAndUpdated)
+        {
+            ArtistMetadataUpdated?.Invoke(this, new ArtistMetadataUpdatedEventArgs(artist.Id, artist.LocalImageCachePath));
+        }
 
-        if (wasMetadataFoundAndUpdated)
-            ArtistMetadataUpdated?.Invoke(this,
-                new ArtistMetadataUpdatedEventArgs(artist.Id, artist.LocalImageCachePath));
+        return (wasMetadataFoundAndUpdated, artist.LocalImageCachePath);
     }
 
     /// <summary>

src/Nagi.WinUI/ViewModels/ArtistViewModel.cs

@@ -332,12 +332,33 @@ private void OnArtistMetadataUpdated(object? sender, ArtistMetadataUpdatedEventA
             });
     }
 
+    /// <summary>
+    ///     Handles batched updates to artist metadata.
+    /// </summary>
+    private void OnArtistMetadataBatchUpdated(object? sender, IEnumerable<ArtistMetadataUpdatedEventArgs> updates)
+    {
+        // Ensure UI updates are performed on the main thread.
+        _dispatcherService.TryEnqueue(() =>
+        {
+            var timestamp = DateTime.UtcNow;
+            foreach (var update in updates)
+            {
+                if (_artistLookup.TryGetValue(update.ArtistId, out var artistVm))
+                {
+                    // Force unique cache buster using current time to ensure UI updates immediately
+                    artistVm.LocalImageCachePath = ImageUriHelper.GetUriWithCacheBuster(update.NewLocalImageCachePath, timestamp);
+                }
+            }
+        });
+    }
+
     /// <summary>
     ///     Subscribes to necessary service events.
     /// </summary>
     public void SubscribeToEvents()
     {
         _libraryService.ArtistMetadataUpdated += OnArtistMetadataUpdated;
+        _libraryService.ArtistMetadataBatchUpdated += OnArtistMetadataBatchUpdated;
     }
 
     /// <summary>
@@ -346,6 +367,7 @@ public void SubscribeToEvents()
     public void UnsubscribeFromEvents()
     {
         _libraryService.ArtistMetadataUpdated -= OnArtistMetadataUpdated;
+        _libraryService.ArtistMetadataBatchUpdated -= OnArtistMetadataBatchUpdated;
     }
 
     /// <summary>

src/Nagi.WinUI/ViewModels/ArtistViewViewModel.cs

@@ -123,7 +123,9 @@ public async Task LoadArtistDetailsAsync(Guid artistId)
 
         // Ensure we don't attach multiple handlers if this method is called again.
         _libraryScanner.ArtistMetadataUpdated -= OnArtistMetadataUpdated;
+        _libraryScanner.ArtistMetadataBatchUpdated -= OnArtistMetadataBatchUpdated;
         _libraryScanner.ArtistMetadataUpdated += OnArtistMetadataUpdated;
+        _libraryScanner.ArtistMetadataBatchUpdated += OnArtistMetadataBatchUpdated;
 
         try
         {
@@ -256,6 +258,20 @@ private void OnArtistMetadataUpdated(object? sender, ArtistMetadataUpdatedEventA
         }
     }
 
+    /// <summary>
+    ///     Handles batched updates to artist metadata.
+    /// </summary>
+    private void OnArtistMetadataBatchUpdated(object? sender, IEnumerable<ArtistMetadataUpdatedEventArgs> updates)
+    {
+        // Check if the current artist is in the batch
+        var update = updates.FirstOrDefault(u => u.ArtistId == _artistId);
+        if (update != null)
+        {
+            _logger.LogDebug("Received batch metadata update for artist ID {ArtistId}", _artistId);
+            OnArtistMetadataUpdated(sender, update);
+        }
+    }
+
 
     protected override Task SaveSortOrderAsync(SongSortOrder sortOrder)
     {
@@ -273,6 +289,7 @@ public override void ResetState()
         base.ResetState();
         _logger.LogDebug("Cleaned up ArtistViewViewModel search resources");
         _libraryScanner.ArtistMetadataUpdated -= OnArtistMetadataUpdated;
+        _libraryScanner.ArtistMetadataBatchUpdated -= OnArtistMetadataBatchUpdated;
 
         // Properly unsubscribe using the stored handler reference.
         Albums.CollectionChanged -= _albumsChangedHandler;