Add save filter result to collection

osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs

@@ -259,7 +259,7 @@
                 InputManager.Click(MouseButton.Left);
             });
 
             AddAssert("dialog displayed", () => dialogOverlay.CurrentDialog is DeleteCollectionDialog);
             AddStep("click cancellation", () =>
             {
                 InputManager.MoveMouseTo(dialogOverlay.CurrentDialog.ChildrenOfType<PopupDialogButton>().Last());
@@ -375,6 +375,133 @@
             assertCollectionCount(1);
         }
 
+        [Test]
+        public void TestBatchAddButtonVisibility()
+        {
+            AddStep("add collection", () => Realm.Write(r => r.Add(new BeatmapCollection(name: "Test collection"))));
+
+            AddAssert("batch add button displayed", () =>
+                dialog.ChildrenOfType<DrawableCollectionListItem.BatchAddToCollectionButton>().Any());
+        }
+
+        [Test]
+        public void TestBatchAddButtonWithNoFilteredBeatmaps()
+        {
+            AddStep("add collection", () => Realm.Write(r => r.Add(new BeatmapCollection(name: "Test collection"))));
+            AddStep("set null filtered beatmaps provider", () => dialog.FilteredBeatmapsProvider = null);
+
+            AddStep("click batch add button", () =>
+            {
+                var button = dialog.ChildrenOfType<DrawableCollectionListItem.BatchAddToCollectionButton>().First();
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("no dialog shown", () => dialogOverlay.CurrentDialog == null);
+        }
+
+        [Test]
+        public void TestBatchAddAllBeatmaps()
+        {
+            BeatmapCollection collection = null!;
+
+            AddStep("add collection and set filtered beatmaps", () =>
+            {
+                Realm.Write(r => r.Add(collection = new BeatmapCollection(name: "Test collection")));
+                var beatmaps = beatmapManager.GetAllUsableBeatmapSets().SelectMany(s => s.Beatmaps).Take(5).ToList();
+                dialog.FilteredBeatmapsProvider = () => beatmaps;
+            });
+
+            AddStep("click batch add button", () =>
+            {
+                var button = dialog.ChildrenOfType<DrawableCollectionListItem.BatchAddToCollectionButton>().First();
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("add dialog shown", () => dialogOverlay.CurrentDialog != null && dialogOverlay.CurrentDialog.GetType().Name == "AddFilteredResultsDialog");
+            AddStep("confirm add all", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog!.ChildrenOfType<PopupDialogButton>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("beatmaps added to collection", () =>
+                collection.BeatmapMD5Hashes.Count > 0);
+        }
+
+        [Test]
+        public void TestBatchRemoveAllBeatmaps()
+        {
+            BeatmapCollection collection = null!;
+
+            AddStep("add collection with all beatmaps", () =>
+            {
+                var beatmaps = beatmapManager.GetAllUsableBeatmapSets().SelectMany(s => s.Beatmaps).Take(5).ToList();
+                var hashes = beatmaps.Select(b => b.MD5Hash).Where(h => !string.IsNullOrEmpty(h)).ToList();
+                Realm.Write(r =>
+                {
+                    r.Add(collection = new BeatmapCollection(name: "Test collection"));
+                    foreach (string hash in hashes)
+                        collection.BeatmapMD5Hashes.Add(hash);
+                });
+                dialog.FilteredBeatmapsProvider = () => beatmaps;
+            });
+
+            AddStep("click batch add button", () =>
+            {
+                var button = dialog.ChildrenOfType<DrawableCollectionListItem.BatchAddToCollectionButton>().First();
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("remove dialog shown", () => dialogOverlay.CurrentDialog != null && dialogOverlay.CurrentDialog.GetType().Name == "RemoveFilteredResultsDialog");
+            AddStep("confirm remove all", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog!.ChildrenOfType<PopupDialogButton>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("beatmaps removed from collection", () =>
+                collection.BeatmapMD5Hashes.Count == 0);
+        }
+
+        [Test]
+        public void TestBatchAddPartialOverlap()
+        {
+            BeatmapCollection collection;
+
+            AddStep("add collection with some beatmaps", () =>
+            {
+                var allBeatmaps = beatmapManager.GetAllUsableBeatmapSets().SelectMany(s => s.Beatmaps).Take(10).ToList();
+                var halfBeatmaps = allBeatmaps.Take(5).ToList();
+                var hashes = halfBeatmaps.Select(b => b.MD5Hash).Where(h => !string.IsNullOrEmpty(h)).ToList();
+                Realm.Write(r =>
+                {
+                    r.Add(collection = new BeatmapCollection(name: "Test collection"));
+                    foreach (string hash in hashes)
+                        collection.BeatmapMD5Hashes.Add(hash);
+                });
+                dialog.FilteredBeatmapsProvider = () => allBeatmaps;
+            });
+
+            AddStep("click batch add button", () =>
+            {
+                var button = dialog.ChildrenOfType<DrawableCollectionListItem.BatchAddToCollectionButton>().First();
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("partial overlap dialog shown", () => dialogOverlay.CurrentDialog != null && dialogOverlay.CurrentDialog.GetType().Name == "PartialOverlapFilteredResultsDialog");
+            AddStep("cancel operation", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog!.ChildrenOfType<PopupDialogButton>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog closed", () => dialogOverlay.CurrentDialog == null);
+        }
+
         private void assertCollectionCount(int count)
             => AddUntilStep($"{count} collections shown", () => dialog.ChildrenOfType<DrawableCollectionListItem>().Count(i => i.IsPresent) == count + 1); // +1 for placeholder
 

osu.Game/Collections/BatchAddToCollectionHandler.cs

@@ -0,0 +1,210 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Collections
+{
+    internal static partial class BatchAddToCollectionHandler
+    {
+        public enum BatchAddOperation
+        {
+            Added,
+            Removed,
+        }
+
+        public readonly record struct BatchAddResult(Guid CollectionId, BatchAddOperation Operation, int Count);
+
+        public static event Action<BatchAddResult>? OperationCompleted;
+
+        private static readonly Dictionary<Guid, (BatchAddResult Result, DateTimeOffset Timestamp)> recent_results = new Dictionary<Guid, (BatchAddResult Result, DateTimeOffset Timestamp)>();
+        private static readonly object recent_results_lock = new object();
+        private static readonly TimeSpan recent_result_lifetime = TimeSpan.FromSeconds(6);
+
+        public static bool TryGetRecentResult(Guid collectionId, out BatchAddResult result)
+        {
+            lock (recent_results_lock)
+            {
+                cleanupExpiredResults();
+
+                if (recent_results.TryGetValue(collectionId, out var entry))
+                {
+                    result = entry.Result;
+                    return true;
+                }
+            }
+
+            result = default;
+            return false;
+        }
+
+        public static void RequestSaveToCollection(
+            Live<BeatmapCollection> collection,
+            Func<IEnumerable<BeatmapInfo>>? filteredBeatmapsProvider,
+            Action<PopupDialog> showDialog)
+        {
+            if (filteredBeatmapsProvider == null)
+                return;
+
+            var hashes = filteredBeatmapsProvider().Select(b => b.MD5Hash)
+                                                   .Where(h => !string.IsNullOrEmpty(h))
+                                                   .Distinct()
+                                                   .ToList();
+
+            if (hashes.Count == 0)
+                return;
+
+            var existing = collection.PerformRead(c => c.BeatmapMD5Hashes.ToList());
+            var intersection = existing.Intersect(hashes).ToList();
+            int overlapCount = intersection.Count;
+
+            if (overlapCount == hashes.Count)
+            {
+                showDialog(new RemoveFilteredResultsDialog(
+                    onRemove: () => runHashRemoval(collection, intersection, BatchAddOperation.Removed)));
+                return;
+            }
+
+            if (overlapCount > 0)
+            {
+                var toAdd = hashes.Except(existing).ToList();
+                var toRemove = intersection;
+
+                showDialog(new PartialOverlapFilteredResultsDialog(
+                    missingCount: toAdd.Count,
+                    duplicateCount: toRemove.Count,
+                    onAddDifference: () => runHashAddition(collection, toAdd, BatchAddOperation.Added),
+                    onRemoveIntersection: () => runHashRemoval(collection, toRemove, BatchAddOperation.Removed)));
+                return;
+            }
+
+            string collectionName = collection.PerformRead(c => c.Name);
+
+            showDialog(new AddFilteredResultsDialog(
+                collectionName,
+                hashes.Count,
+                onAddAll: () => runHashAddition(collection, hashes, BatchAddOperation.Added)));
+        }
+
+        private static void runHashAddition(Live<BeatmapCollection> collection, IReadOnlyList<string> hashes, BatchAddOperation operation)
+        {
+            if (hashes.Count == 0)
+                return;
+
+            Task.Run(() => collection.PerformWrite(c =>
+            {
+                int affected = 0;
+
+                foreach (string hash in hashes)
+                {
+                    if (c.BeatmapMD5Hashes.Contains(hash))
+                        continue;
+
+                    c.BeatmapMD5Hashes.Add(hash);
+                    affected++;
+                }
+
+                if (affected > 0)
+                    notifyOperationCompleted(c.ID, operation, affected);
+            }));
+        }
+
+        private static void runHashRemoval(Live<BeatmapCollection> collection, IReadOnlyList<string> hashes, BatchAddOperation operation)
+        {
+            Task.Run(() => collection.PerformWrite(c =>
+            {
+                int affected = 0;
+
+                foreach (string hash in hashes)
+                {
+                    if (c.BeatmapMD5Hashes.Remove(hash))
+                        affected++;
+                }
+
+                if (affected > 0)
+                    notifyOperationCompleted(c.ID, operation, affected);
+            }));
+        }
+
+        private static void notifyOperationCompleted(Guid collectionId, BatchAddOperation operation, int count)
+        {
+            var result = new BatchAddResult(collectionId, operation, count);
+
+            lock (recent_results_lock)
+            {
+                recent_results[collectionId] = (result, DateTimeOffset.UtcNow);
+                cleanupExpiredResults();
+            }
+
+            OperationCompleted?.Invoke(result);
+        }
+
+        private static void cleanupExpiredResults()
+        {
+            var now = DateTimeOffset.UtcNow;
+
+            foreach (var entry in recent_results.ToArray())
+            {
+                if (now - entry.Value.Timestamp > recent_result_lifetime)
+                    recent_results.Remove(entry.Key);
+            }
+        }
+
+        private partial class AddFilteredResultsDialog : DangerousActionDialog
+        {
+            public AddFilteredResultsDialog(string collectionName, int beatmapCount, Action onAddAll)
+            {
+                Icon = FontAwesome.Solid.Check;
+                HeaderText = "Add all visible beatmaps to collection";
+                BodyText = $"Add {beatmapCount:#,0} beatmaps to \"{collectionName}\"?";
+                DangerousAction = onAddAll;
+            }
+        }
+
+        private partial class RemoveFilteredResultsDialog : DangerousActionDialog
+        {
+            public RemoveFilteredResultsDialog(Action onRemove)
+            {
+                Icon = FontAwesome.Solid.Trash;
+                HeaderText = "Remove all visible beatmaps from collection";
+                BodyText = "The collection already contains all the visible beatmaps, do you want to remove these beatmaps from the collection?";
+                DangerousAction = onRemove;
+            }
+        }
+
+        private partial class PartialOverlapFilteredResultsDialog : DangerousActionDialog
+        {
+            public PartialOverlapFilteredResultsDialog(int missingCount, int duplicateCount, Action onAddDifference, Action onRemoveIntersection)
+            {
+                Icon = FontAwesome.Solid.Question;
+                HeaderText = "Add or remove visible beatmaps";
+                BodyText = $"{missingCount:#,0} of the visible beatmaps are missing from this collection."
+                           + $"\n{duplicateCount:#,0} of the visible beatmaps already exist in this collection.";
+                Buttons = new PopupDialogButton[]
+                {
+                    new PopupDialogDangerousButton
+                    {
+                        Text = "Add missing beatmaps",
+                        Action = onAddDifference,
+                    },
+                    new PopupDialogDangerousButton
+                    {
+                        Text = "Remove existing beatmaps",
+                        Action = onRemoveIntersection,
+                    },
+                    new PopupDialogCancelButton
+                    {
+                        Text = "Cancel"
+                    }
+                };
+            }
+        }
+    }
+}