From 982cbfcf5eae6fcc93b92cfc6d05fd1f8bc12536 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Sun, 4 Aug 2024 17:41:49 +0700
Subject: [PATCH 01/22] [ZZZ GSP] Add experimental Mobile Mode toggle

---
 .../ZenlessGameSettingsPage.Ext.cs                  | 13 +++++++++++--
 .../GameSettingsPages/ZenlessGameSettingsPage.xaml  |  4 +---
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs
index af9874f1e..9675bf970 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs
@@ -301,8 +301,17 @@ public bool IsGameBoost
         
         public bool IsMobileMode
         {
-            get => Settings?.SettingsCollapseMisc?.LaunchMobileMode ?? false;
-            set => Settings.SettingsCollapseMisc.LaunchMobileMode = value;
+            get
+            {
+                var cSet = Settings?.SettingsCollapseMisc?.LaunchMobileMode ?? false;
+                var gSet = Settings.GeneralData.LocalUILayoutPlatform == 1;
+                return cSet || gSet;
+            }
+            set
+            {
+                Settings.SettingsCollapseMisc.LaunchMobileMode = value;
+                Settings.GeneralData.LocalUILayoutPlatform     = value ? 1 : 3;
+            }
         }
         #endregion
 
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml
index 5b60e918c..28bd8cd81 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml
@@ -162,9 +162,7 @@
                                             <CheckBox x:Name="MobileModeToggle"
                                                       HorizontalAlignment="Left"
                                                       VerticalAlignment="Center"
-                                                      IsChecked="{x:Bind IsMobileMode, Mode=TwoWay}"
-                                                      IsEnabled="False"
-                                                      Visibility="Collapsed">
+                                                      IsChecked="{x:Bind IsMobileMode, Mode=TwoWay}">
                                                 <TextBlock Text="{x:Bind helper:Locale.Lang._GameSettingsPage.MobileLayout}"
                                                            TextWrapping="Wrap" />
                                             </CheckBox>

From afeb190ebcd2a8a6ab0dbfa7cb61d5e5747b3038 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Thu, 19 Dec 2024 16:04:26 +0700
Subject: [PATCH 02/22] what in the absolute FRICK - Fix cleanup method when
 using >1000 files

DO NOT ASK HOW LONG THIS TOOK
---
 .../InstallManagerBase.PkgVersion.cs          |  76 ++---
 .../XAMLs/MainApp/Pages/FileCleanupPage.xaml  |   2 +-
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 277 +++++++++++++++---
 3 files changed, 274 insertions(+), 81 deletions(-)

diff --git a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
index 35493cd82..c01eb37f2 100644
--- a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
+++ b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
@@ -102,7 +102,7 @@ public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
         {
             // Get the unused file info asynchronously
             List<LocalFileInfo> unusedFileInfo = await GetUnusedFileInfoList(withDialog);
-
+            
             // Spawn dialog if used
             if (withDialog)
             {
@@ -113,11 +113,13 @@ public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
                     mainWindow.overlayFrame.Navigate(typeof(FileCleanupPage), null,
                                                      new DrillInNavigationTransitionInfo());
                 }
-
+                
                 if (FileCleanupPage.Current == null)
                     return;
-
-                FileCleanupPage.Current.InjectFileInfoSource(unusedFileInfo);
+                await FileCleanupPage.Current.InjectFileInfoSource(unusedFileInfo);
+                
+                LoadingMessageHelper.HideLoadingFrame();
+                
                 FileCleanupPage.Current.MenuExitButton.Click   += ExitFromOverlay;
                 FileCleanupPage.Current.MenuReScanButton.Click += ExitFromOverlay;
                 FileCleanupPage.Current.MenuReScanButton.Click += async (_, _) =>
@@ -170,9 +172,9 @@ protected virtual async Task<List<LocalFileInfo>> GetUnusedFileInfoList(bool inc
                 {
                     // Initialize new proxy-aware HttpClient
                     using HttpClient httpClient = new HttpClientBuilder()
-                        .UseLauncherConfig(_downloadThreadCount + _downloadThreadCountReserved)
-                        .SetAllowedDecompression(DecompressionMethods.None)
-                        .Create();
+                                                 .UseLauncherConfig(_downloadThreadCount + _downloadThreadCountReserved)
+                                                 .SetAllowedDecompression(DecompressionMethods.None)
+                                                 .Create();
 
                     // Initialize and get game state, then get the latest package info
                     LoadingMessageHelper.SetMessage(
@@ -238,9 +240,10 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
                                      true);
                     }
                 }
-                
+
                 // Add pre-download zips into the ignored list 
-                RegionResourceVersion? packagePreDownloadList = _gameVersionManager.GetGamePreloadZip()?.FirstOrDefault();
+                RegionResourceVersion? packagePreDownloadList =
+                    _gameVersionManager.GetGamePreloadZip()?.FirstOrDefault();
                 if (packagePreDownloadList != null)
                 {
                     var preDownloadZips = new List<string>();
@@ -253,7 +256,7 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
                         preDownloadZips.AddRange(packagePreDownloadList.voice_packs
                                                                        .Select(audioRes =>
                                                                                    new GameInstallPackage(audioRes,
-                                                                                            _gamePath)
+                                                                                       _gamePath)
                                                                                    {
                                                                                        PackageType =
                                                                                            GameInstallPackageType.Audio
@@ -268,11 +271,11 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
                         ignoredFiles = ignoredFiles.Concat(preDownloadZips).ToArray();
                     }
                 }
-                
+
                 if (ignoredFiles.Length > 0)
                     LogWriteLine($"[GetUnusedFileInfoList] Final ignored file list:\r\n{string.Join(", ", ignoredFiles)}",
                                  LogType.Scheme, true);
-                
+
                 // Get the list of the local file paths
                 List<LocalFileInfo> localFileInfo = [];
                 await GetRelativeLocalFilePaths(localFileInfo, includeZipCheck, gameStateEnum, _token.Token);
@@ -295,9 +298,10 @@ await Task.Run(() =>
 
                 return unusedFileInfo;
             }
-            finally
+            catch (Exception ex)
             {
-                LoadingMessageHelper.HideLoadingFrame();
+                ErrorSender.SendException(ex);
+                return new List<LocalFileInfo>();
             }
         }
 
@@ -465,14 +469,15 @@ protected virtual async Task GetRelativeLocalFilePaths(List<LocalFileInfo> local
         {
             await Task.Run(() =>
                            {
-                               int           count     = 0;
-                               long          totalSize = 0;
-                               string        gamePath  = _gamePath;
-                               DirectoryInfo dirInfo   = new DirectoryInfo(gamePath);
+                               int           count          = 0;
+                               long          totalSize      = 0;
+                               string        gamePath       = _gamePath;
+                               DirectoryInfo dirInfo        = new DirectoryInfo(gamePath);
+                               int           updateInterval = 100; // Update UI every 100 files
+                               int           processedCount = 0;
 
                                // Do the do in parallel since it will be a really CPU expensive task due to janky checks here and there.
-                               Parallel.ForEach(dirInfo
-                                                   .EnumerateFiles("*", SearchOption.AllDirectories),
+                               Parallel.ForEach(dirInfo.EnumerateFiles("*", SearchOption.AllDirectories),
                                                 new ParallelOptions { CancellationToken = token },
                                                 (fileInfo, _) =>
                                                 {
@@ -481,23 +486,26 @@ await Task.Run(() =>
 
                                                     // Do the check within the lambda function to possibly check the file
                                                     // condition in multithread
-                                                    if (!IsCategorizedAsGameFile(fileInfo, gamePath, includeZipCheck,
-                                                                 gameState,
-                                                                 out LocalFileInfo localFileInfo))
+                                                    if (!IsCategorizedAsGameFile(fileInfo, gamePath, includeZipCheck, gameState, out LocalFileInfo localFileInfo))
                                                         return;
 
-                                                    Interlocked.Add(ref totalSize,
-                                                                    fileInfo.Exists ? fileInfo.Length : 0);
+                                                    Interlocked.Add(ref totalSize, fileInfo.Exists ? fileInfo.Length : 0);
                                                     Interlocked.Increment(ref count);
-                                                    _parentUI.DispatcherQueue.TryEnqueue(() =>
-                                                                     LoadingMessageHelper.SetMessage(
-                                                                          Locale.Lang._FileCleanupPage.LoadingTitle,
-                                                                          string
-                                                                             .Format(Locale.Lang._FileCleanupPage.LoadingSubtitle1,
-                                                                                       count,
-                                                                                       ConverterTool
-                                                                                          .SummarizeSizeSimple(totalSize))
-                                                                         ));
+                                                    int currentCount = Interlocked.Increment(ref processedCount);
+
+                                                    if (currentCount % updateInterval == 0)
+                                                    {
+                                                        _parentUI.DispatcherQueue.TryEnqueue(() =>
+                                                        {
+                                                            LoadingMessageHelper.SetMessage(
+                                                                 Locale.Lang._FileCleanupPage.LoadingTitle,
+                                                                 string.Format(Locale.Lang._FileCleanupPage.LoadingSubtitle1,
+                                                                               count,
+                                                                               ConverterTool.SummarizeSizeSimple(totalSize))
+                                                                );
+                                                        });
+                                                    }
+
                                                     lock (localFileInfoList)
                                                     {
                                                         localFileInfoList.Add(localFileInfo);
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml
index 4a2fe1c32..42502bc10 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml
@@ -156,7 +156,7 @@
                 </Grid.ColumnDefinitions>
                 <CheckBox x:Name="ToggleCheckAllCheckBox"
                           Checked="ToggleCheckAll"
-                          IsChecked="True"
+                          IsChecked="False"
                           Unchecked="ToggleCheckAll" />
                 <Button x:Name="DeleteSelectedFiles"
                         Grid.Column="0"
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 45c4cb48b..860b80f79 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -1,7 +1,9 @@
 using CollapseLauncher.CustomControls;
 using CollapseLauncher.Dialogs;
 using CollapseLauncher.Extension;
+using CollapseLauncher.Helper.Loading;
 using CollapseLauncher.InstallManager.Base;
+using CommunityToolkit.WinUI;
 using Hi3Helper;
 using Hi3Helper.Data;
 using Hi3Helper.Win32.Native.ManagedTools;
@@ -12,8 +14,10 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Numerics;
 using System.Threading.Tasks;
 
 // ReSharper disable CheckNamespace
@@ -34,11 +38,6 @@ public FileCleanupPage()
             Current = this;
             Loaded += (_, _) =>
                       {
-                          foreach (LocalFileInfo asset in FileInfoSource)
-                          {
-                              ListViewTable.SelectedItems.Add(asset);
-                          }
-
                           FileInfoSource.CollectionChanged += UpdateUIOnCollectionChange;
                       };
         }
@@ -49,17 +48,87 @@ public FileCleanupPage()
         private string _assetTotalSizeString = string.Empty;
         private long   _assetSelectedSize;
 
-        public void InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
+        private ObservableCollection<LocalFileInfo> _localFileCollection;
+        public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
         {
+            var s = new Stopwatch();
+            s.Start();
+            
             FileInfoSource.Clear();
-            foreach (LocalFileInfo fileInfo in fileInfoList)
+            _assetTotalSize = 0;
+            int batchSize = Math.Clamp(FileInfoSource.Count / (Environment.ProcessorCount * 4), 50, 1000);
+            
+            _localFileCollection = new ObservableCollection<LocalFileInfo>(fileInfoList);
+
+            var batches = _localFileCollection
+                         .Select((file, index) => new { File = file, Index = index })
+                         .GroupBy(x => x.Index / batchSize)
+                         .Select(group => group.Select(x => x.File).ToList());
+            var tasks = new List<Task>();
+            Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Starting to inject file info source with {_localFileCollection.Count} items", LogType.Scheme);
+            
+            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "TODO: Translate TempAsync1");
+
+            int b = 0;
+            await Task.Run(() =>
+                           {
+                               foreach (var batch in batches)
+                               {
+                                   tasks.Add(EnqueueOnDispatcherQueueAsync(() =>
+                                                                           {
+                                                                               var sI = new Stopwatch();
+                                                                               s.Start();
+                                                                               foreach (var fileInfoInner in batch)
+                                                                               {
+                                                                                   FileInfoSource.Add(fileInfoInner);
+                                                                                   _localFileCollection.Remove(fileInfoInner);
+                                                                               }
+                                                                               sI.Stop();
+                                                                               Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished batch #{b} with {batch.Count} items after {s.ElapsedMilliseconds} ms", LogType.Scheme);
+                                                                           }));
+                                   
+                               }
+                           });
+            await Task.WhenAll(tasks);
+
+            await EnqueueOnDispatcherQueueAsync(() =>
+                                          {
+                                              var sI = new Stopwatch();
+                                              sI.Start();
+                                              while (_localFileCollection.Count > 0)
+                                              {
+                                                  FileInfoSource.Add(_localFileCollection[0]);
+                                                  _localFileCollection.RemoveAt(0);
+                                              }
+
+                                              sI.Stop();
+                                              Logger
+                                                 .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished last batch at #{b} after {_localFileCollection.Count} items",
+                                                               LogType.Scheme);
+                                          });
+            
+            while (_localFileCollection.Count != 0)
             {
-                FileInfoSource.Add(fileInfo);
-                _assetTotalSize += fileInfo.FileSize;
+                FileInfoSource.Add(_localFileCollection[0]);
+                _localFileCollection.RemoveAt(0);
+            }
+            
+            await Task.Run(() => _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize));
+            await DispatcherQueue.EnqueueAsync(() => UpdateUIOnCollectionChange(FileInfoSource, null));
+            s.Stop();
+            Logger.LogWriteLine($"InjectFileInfoSource done after {s.ElapsedMilliseconds} ms", LogType.Scheme);
+
+            if (ListViewTable.Items.Count < 1000)
+            {
+                CheckAll();
+            }
+            else
+            {
+                ToggleCheckAllCheckBox.Content = Locale.Lang._FileCleanupPage.BottomCheckboxNoFileSelected;
+                DeleteSelectedFilesText.Text =
+                    string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, 0);
             }
 
-            _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize);
-            UpdateUIOnCollectionChange(FileInfoSource, null);
         }
 
         private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedEventArgs? args)
@@ -80,60 +149,176 @@ private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedE
         }
 
 
-        private void ToggleCheckAll(object sender, RoutedEventArgs e)
+        private async void ToggleCheckAll(object sender, RoutedEventArgs e)
         {
-            if (sender is not CheckBox checkBox)
+            var s = new Stopwatch();
+            LoadingMessageHelper.Initialize();
+            LoadingMessageHelper.ShowLoadingFrame();
+            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "UI might freeze for a moment...");
+            await Task.Delay(100);
+            s.Start();
+            if (sender is CheckBox checkBox)
             {
-                return;
-            }
+                bool toCheck = checkBox.IsChecked ?? false;
+                await ToggleCheckAllInnerAsync(toCheck);
+            } 
+            s.Stop();
+            LoadingMessageHelper.HideLoadingFrame();
+            Logger.LogWriteLine("[FileCleanupPage::ToggleCheckAll] Elapsed time: " + s.ElapsedMilliseconds + "ms", LogType.Scheme);
+        }
 
-            bool toCheck = checkBox.IsChecked ?? false;
-            SelectAllToggle(toCheck);
+        private async void CheckAll()
+        {
+            await ToggleCheckAllInnerAsync(true);
         }
 
-        private void SelectAllToggle(bool selectAll)
+        private ObservableCollection<LocalFileInfo> _fileInfoSourceCopy;
+
+        private async Task ToggleCheckAllInnerAsync(bool selectAll)
         {
             if (selectAll)
             {
-                foreach (LocalFileInfo asset in FileInfoSource)
-                {
-                    if (ListViewTable.SelectedItems.IndexOf(asset) < 0)
-                    {
-                        ListViewTable.SelectedItems.Add(asset);
-                    }
-                }
+                int                 batchSize = Math.Clamp(FileInfoSource.Count / (Environment.ProcessorCount * 4), 50, 1000);
+                var                 tasks     = new List<Task>();
+                _fileInfoSourceCopy = new ObservableCollection<LocalFileInfo>(FileInfoSource);
+                int b = 0;
+                await Task.Run(() =>
+                               {
+                                   var batches = FileInfoSource
+                                                .Select((file, index) => new { File = file, Index = index })
+                                                .GroupBy(x => x.Index / batchSize)
+                                                .Select(group => group.Select(x => x.File).ToList());
+                                   
+                                   foreach (var batch in batches)
+                                   {
+                                       tasks.Add(EnqueueOnDispatcherQueueAsync(() =>
+                                                                               {
+                                                                                   var s = new Stopwatch();
+                                                                                   s.Start();
+                                                                                   foreach (var fileInfo in batch)
+                                                                                   {
+                                                                                       ListViewTable.SelectedItems.Add(fileInfo);
+                                                                                       _fileInfoSourceCopy.Remove(fileInfo);
+                                                                                   }
+                                                                                   s.Stop();
+                                                                                   Logger.LogWriteLine($"[FileCleanupPage::ToggleCheckAllInnerAsync] Finished batch #{b} with {batch.Count} items after {s.ElapsedMilliseconds} ms", LogType.Scheme);
+                                                                                   
+                                                                                   b++;
+                                                                               }));
+                                   }
+                               });
+
+                await Task.WhenAll(tasks);
+
+                await EnqueueOnDispatcherQueueAsync(() =>
+                                                    {
+                                                        var i = 0;
+                                                        while (_fileInfoSourceCopy.Count > 0)
+                                                        {
+                                                            ListViewTable.SelectedItems.Add(_fileInfoSourceCopy[0]);
+                                                            _fileInfoSourceCopy.RemoveAt(0);
+                                                            i++;
+                                                        }
+
+                                                        Logger
+                                                           .LogWriteLine($"[FileCleanupPage::ToggleCheckAllInnerAsync] Finished last batch at #{b} after {i} items",
+                                                                         LogType.Scheme);
+                                                    });
             }
             else
             {
-                ListViewTable.SelectedItems.Clear();
+                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.SelectedItems.Clear());
             }
         }
 
-        private void ListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        private async void ListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            var removedItems = e.RemovedItems.OfType<LocalFileInfo>().ToList();
+            var addedItems   = e.AddedItems.OfType<LocalFileInfo>().ToList();
+
+            long removedSize = await Task.Run(() => SumFileSizes(removedItems));
+            long addedSize   = await Task.Run(() => SumFileSizes(addedItems));
+
+            _selectedAssetsCount += addedItems.Count - removedItems.Count;
+            _assetSelectedSize   += addedSize - removedSize;
+
+            await EnqueueOnDispatcherQueueAsync(() =>
+            {
+                if (_selectedAssetsCount > 0)
+                {
+                    ToggleCheckAllCheckBox.Content = string.Format(
+                                                                   Locale.Lang._FileCleanupPage.BottomCheckboxFilesSelected,
+                                                                    _selectedAssetsCount,
+                                                                    ConverterTool.SummarizeSizeSimple(_assetSelectedSize),
+                                                                    _assetTotalSizeString);
+                }
+                else
+                {
+                    ToggleCheckAllCheckBox.Content = Locale.Lang._FileCleanupPage.BottomCheckboxNoFileSelected;
+                }
+
+                DeleteSelectedFilesText.Text =
+                    string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, _selectedAssetsCount);
+                DeleteSelectedFiles.IsEnabled = _selectedAssetsCount > 0;
+
+                ToggleCheckAllCheckBox.IsChecked = _selectedAssetsCount == 0
+                    ? false
+                    : _selectedAssetsCount == FileInfoSource.Count ? true : null;
+            });
+        }
+
+        private long SumFileSizes(List<LocalFileInfo> items)
         {
-            _selectedAssetsCount -= e.RemovedItems.Count;
-            _assetSelectedSize   -= e.RemovedItems.OfType<LocalFileInfo>().Sum(x => x.FileSize);
-
-            _selectedAssetsCount += e.AddedItems.Count;
-            _assetSelectedSize   += e.AddedItems.OfType<LocalFileInfo>().Sum(x => x.FileSize);
-
-            ToggleCheckAllCheckBox.Content = _selectedAssetsCount > 0
-                ? string.Format(Locale.Lang._FileCleanupPage.BottomCheckboxFilesSelected,
-                                _selectedAssetsCount, ConverterTool.SummarizeSizeSimple(_assetSelectedSize),
-                                _assetTotalSizeString)
-                : Locale.Lang._FileCleanupPage.BottomCheckboxNoFileSelected;
-            DeleteSelectedFilesText.Text =
-                string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, _selectedAssetsCount);
-            DeleteSelectedFiles.IsEnabled = _selectedAssetsCount > 0;
-
-            if (_selectedAssetsCount != 0 && _selectedAssetsCount != FileInfoSource.Count)
+            var vectorSize = Vector<long>.Count;
+            var sumVector  = Vector<long>.Zero;
+
+            int i = 0;
+
+            // Vectorized loop
+            for (; i <= items.Count - vectorSize; i += vectorSize)
+            {
+                var fileSizeArray = new long[vectorSize];
+                for (int j = 0; j < vectorSize; j++)
+                {
+                    fileSizeArray[j] = items[i + j].FileSize;
+                }
+
+                var vector = new Vector<long>(fileSizeArray);
+                sumVector += vector;
+            }
+
+            // Aggregate SIMD results
+            long total = 0;
+            for (int j = 0; j < vectorSize; j++)
             {
-                ToggleCheckAllCheckBox.IsChecked = null;
+                total += sumVector[j];
             }
-            else
+
+            // Remainder loop for non-vectorized items
+            for (; i < items.Count; i++)
             {
-                ToggleCheckAllCheckBox.IsChecked = _selectedAssetsCount == FileInfoSource.Count;
+                total += items[i].FileSize;
             }
+
+            return total;
+        }
+
+        private Task EnqueueOnDispatcherQueueAsync(Action action)
+        {
+            var tcs = new TaskCompletionSource();
+            DispatcherQueue.TryEnqueue(() =>
+                                       {
+                                           try
+                                           {
+                                               action();
+                                               tcs.SetResult();
+                                           }
+                                           catch (Exception ex)
+                                           {
+                                               tcs.SetException(ex);
+                                           }
+                                       });
+            return tcs.Task;
         }
 
         private async void DeleteAllFiles_Click(object sender, RoutedEventArgs e)

From a3ca990945e27bd35f7edd52ffe28358d2e369e2 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Thu, 19 Dec 2024 16:21:05 +0700
Subject: [PATCH 03/22] fix logging

---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 31 ++++++++++---------
 CollapseLauncher/packages.lock.json           | 15 +++++++++
 2 files changed, 32 insertions(+), 14 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 860b80f79..3383aa476 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -85,6 +85,7 @@ await Task.Run(() =>
                                                                                }
                                                                                sI.Stop();
                                                                                Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished batch #{b} with {batch.Count} items after {s.ElapsedMilliseconds} ms", LogType.Scheme);
+                                                                               b++;
                                                                            }));
                                    
                                }
@@ -92,20 +93,22 @@ await Task.Run(() =>
             await Task.WhenAll(tasks);
 
             await EnqueueOnDispatcherQueueAsync(() =>
-                                          {
-                                              var sI = new Stopwatch();
-                                              sI.Start();
-                                              while (_localFileCollection.Count > 0)
-                                              {
-                                                  FileInfoSource.Add(_localFileCollection[0]);
-                                                  _localFileCollection.RemoveAt(0);
-                                              }
-
-                                              sI.Stop();
-                                              Logger
-                                                 .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished last batch at #{b} after {_localFileCollection.Count} items",
-                                                               LogType.Scheme);
-                                          });
+                                                {
+                                                    var i  = 0;
+                                                    var sI = new Stopwatch();
+                                                    sI.Start();
+                                                    while (_localFileCollection.Count > 0)
+                                                    {
+                                                        FileInfoSource.Add(_localFileCollection[0]);
+                                                        _localFileCollection.RemoveAt(0);
+                                                        i++;
+                                                    }
+
+                                                    sI.Stop();
+                                                    Logger
+                                                       .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished last batch at #{b} after {i} items",
+                                                                     LogType.Scheme);
+                                                });
             
             while (_localFileCollection.Count != 0)
             {
diff --git a/CollapseLauncher/packages.lock.json b/CollapseLauncher/packages.lock.json
index 44ca5c500..cf444c780 100644
--- a/CollapseLauncher/packages.lock.json
+++ b/CollapseLauncher/packages.lock.json
@@ -105,6 +105,12 @@
         "resolved": "0.38.0",
         "contentHash": "zfi6kNm5QJnsCGm5a0hMG2qw8juYbOfsS4c1OuTcqkbYQUCdkam6d6Nt7nPIrbV4D+U7sHChidSQlg+ViiMPuw=="
       },
+      "Microsoft.DotNet.ILCompiler": {
+        "type": "Direct",
+        "requested": "[9.0.0, )",
+        "resolved": "9.0.0",
+        "contentHash": "bbnlV2PbUmCQ8Ndpx0kJaicLyV28IU+4IzyctQLL57+DxrHurYr2qsJrC8+yD44Q0DyPfv2oM168c1Tk6Bxbmg=="
+      },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Direct",
         "requested": "[9.0.0, )",
@@ -516,6 +522,15 @@
         "resolved": "0.5.0",
         "contentHash": "5Tw6O9sBDAN1aV+kpOSVvqvFk6Ahk6bYz0TTx3808Dp40M45gKTtzTzI9SS1VeAkljE6BAOeKaykpPnG36oOgw=="
       },
+      "Microsoft.DotNet.ILCompiler": {
+        "type": "Direct",
+        "requested": "[9.0.0, )",
+        "resolved": "9.0.0",
+        "contentHash": "bbnlV2PbUmCQ8Ndpx0kJaicLyV28IU+4IzyctQLL57+DxrHurYr2qsJrC8+yD44Q0DyPfv2oM168c1Tk6Bxbmg==",
+        "dependencies": {
+          "runtime.win-x64.Microsoft.DotNet.ILCompiler": "9.0.0"
+        }
+      },
       "Microsoft.Graphics.Win2D": {
         "type": "Direct",
         "requested": "[1.3.0, )",

From a65b93748c1cc54f905c2f8ee0b0bfaac928e5dc Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <28079733+bagusnl@users.noreply.github.com>
Date: Thu, 19 Dec 2024 16:43:31 +0700
Subject: [PATCH 04/22] how is it not clear that idk what im doing

---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 39 ++++++++++---------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 3383aa476..ecd53d685 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -86,30 +86,34 @@ await Task.Run(() =>
                                                                                sI.Stop();
                                                                                Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished batch #{b} with {batch.Count} items after {s.ElapsedMilliseconds} ms", LogType.Scheme);
                                                                                b++;
+                                                                               sI = null;
                                                                            }));
                                    
                                }
                            });
             await Task.WhenAll(tasks);
 
-            await EnqueueOnDispatcherQueueAsync(() =>
-                                                {
-                                                    var i  = 0;
-                                                    var sI = new Stopwatch();
-                                                    sI.Start();
-                                                    while (_localFileCollection.Count > 0)
+            if (_localFileCollection.Count > 0)
+            {
+                await EnqueueOnDispatcherQueueAsync(() =>
                                                     {
-                                                        FileInfoSource.Add(_localFileCollection[0]);
-                                                        _localFileCollection.RemoveAt(0);
-                                                        i++;
-                                                    }
-
-                                                    sI.Stop();
-                                                    Logger
-                                                       .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished last batch at #{b} after {i} items",
-                                                                     LogType.Scheme);
-                                                });
-            
+                                                        var i  = 0;
+                                                        var sI = new Stopwatch();
+                                                        sI.Start();
+                                                        while (_localFileCollection.Count > 0)
+                                                        {
+                                                            FileInfoSource.Add(_localFileCollection[0]);
+                                                            _localFileCollection.RemoveAt(0);
+                                                            i++;
+                                                        }
+
+                                                        sI.Stop();
+                                                        Logger
+                                                        .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished last batch at #{b} after {i} items in {sI.ElapsedMilliseconds} ms",
+                                                                        LogType.Scheme);
+                                                    });
+            }
+
             while (_localFileCollection.Count != 0)
             {
                 FileInfoSource.Add(_localFileCollection[0]);
@@ -131,7 +135,6 @@ await EnqueueOnDispatcherQueueAsync(() =>
                 DeleteSelectedFilesText.Text =
                     string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, 0);
             }
-
         }
 
         private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedEventArgs? args)

From 442fcf45192ea146a5a9359e9383b885f856838a Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Fri, 20 Dec 2024 03:48:00 +0700
Subject: [PATCH 05/22] Hilariously improve select all speed by using a
 one-liner instead of 46 lines of code

---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 74 +++++--------------
 1 file changed, 19 insertions(+), 55 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 3383aa476..75cba4b14 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -11,6 +11,7 @@
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
@@ -18,6 +19,7 @@
 using System.IO;
 using System.Linq;
 using System.Numerics;
+using System.Threading;
 using System.Threading.Tasks;
 
 // ReSharper disable CheckNamespace
@@ -175,58 +177,11 @@ private async void CheckAll()
             await ToggleCheckAllInnerAsync(true);
         }
 
-        private ObservableCollection<LocalFileInfo> _fileInfoSourceCopy;
-
         private async Task ToggleCheckAllInnerAsync(bool selectAll)
         {
             if (selectAll)
             {
-                int                 batchSize = Math.Clamp(FileInfoSource.Count / (Environment.ProcessorCount * 4), 50, 1000);
-                var                 tasks     = new List<Task>();
-                _fileInfoSourceCopy = new ObservableCollection<LocalFileInfo>(FileInfoSource);
-                int b = 0;
-                await Task.Run(() =>
-                               {
-                                   var batches = FileInfoSource
-                                                .Select((file, index) => new { File = file, Index = index })
-                                                .GroupBy(x => x.Index / batchSize)
-                                                .Select(group => group.Select(x => x.File).ToList());
-                                   
-                                   foreach (var batch in batches)
-                                   {
-                                       tasks.Add(EnqueueOnDispatcherQueueAsync(() =>
-                                                                               {
-                                                                                   var s = new Stopwatch();
-                                                                                   s.Start();
-                                                                                   foreach (var fileInfo in batch)
-                                                                                   {
-                                                                                       ListViewTable.SelectedItems.Add(fileInfo);
-                                                                                       _fileInfoSourceCopy.Remove(fileInfo);
-                                                                                   }
-                                                                                   s.Stop();
-                                                                                   Logger.LogWriteLine($"[FileCleanupPage::ToggleCheckAllInnerAsync] Finished batch #{b} with {batch.Count} items after {s.ElapsedMilliseconds} ms", LogType.Scheme);
-                                                                                   
-                                                                                   b++;
-                                                                               }));
-                                   }
-                               });
-
-                await Task.WhenAll(tasks);
-
-                await EnqueueOnDispatcherQueueAsync(() =>
-                                                    {
-                                                        var i = 0;
-                                                        while (_fileInfoSourceCopy.Count > 0)
-                                                        {
-                                                            ListViewTable.SelectedItems.Add(_fileInfoSourceCopy[0]);
-                                                            _fileInfoSourceCopy.RemoveAt(0);
-                                                            i++;
-                                                        }
-
-                                                        Logger
-                                                           .LogWriteLine($"[FileCleanupPage::ToggleCheckAllInnerAsync] Finished last batch at #{b} after {i} items",
-                                                                         LogType.Scheme);
-                                                    });
+                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.SelectAll());
             }
             else
             {
@@ -382,6 +337,9 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                 return;
             }
 
+            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "TODO: Translate - Deleting files...");
+            LoadingMessageHelper.ShowLoadingFrame();
+            
             if (isToRecycleBin)
             {
                 IList<string> toBeDeleted = new List<string>();
@@ -421,8 +379,14 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
             }
             else
             {
-                foreach (LocalFileInfo fileInfo in deletionSource)
+                ConcurrentDictionary<LocalFileInfo, byte> processedFiles = new();
+                
+                var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
+                await Parallel.ForEachAsync(deletionSource, options, async (fileInfo, _) =>
                 {
+                    if (!processedFiles.TryAdd(fileInfo, 0))
+                        return;    
+
                     try
                     {
                         FileInfo fileInfoN = fileInfo.ToFileInfo();
@@ -432,16 +396,16 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                             fileInfoN.Delete();
                         }
 
-                        FileInfoSource.Remove(fileInfo);
-                        ++deleteSuccess;
+                        await EnqueueOnDispatcherQueueAsync(() => FileInfoSource.Remove(fileInfo));
+                        Interlocked.Increment(ref deleteSuccess);
                     }
                     catch (Exception ex)
                     {
-                        ++deleteFailed;
-                        Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
-                                            LogType.Error, true);
+                     Interlocked.Increment(ref deleteFailed);
+                     Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
+                                         LogType.Error, true);
                     }
-                }
+                });
             }
 
             string diagTitle = dialogResult == ContentDialogResult.Primary

From 32c6cae2f350a20b9fb51f21cc8d6ca171785ba9 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Fri, 20 Dec 2024 04:30:04 +0700
Subject: [PATCH 06/22] More improvements

InjectFileSource
1. Increase possible batch size
2. Use Interlock.Increment

Delete to Recycle Bin
1. Improve FileInfoSource removal speed
---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 24 ++++++++++---------
 Hi3Helper.EncTool                             |  2 +-
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 94d336969..c5ab9f399 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -58,10 +58,10 @@ public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
             
             FileInfoSource.Clear();
             _assetTotalSize = 0;
-            int batchSize = Math.Clamp(FileInfoSource.Count / (Environment.ProcessorCount * 4), 50, 1000);
             
             _localFileCollection = new ObservableCollection<LocalFileInfo>(fileInfoList);
-
+            int batchSize = Math.Clamp(_localFileCollection.Count / Environment.ProcessorCount, 50, 5000);
+            
             var batches = _localFileCollection
                          .Select((file, index) => new { File = file, Index = index })
                          .GroupBy(x => x.Index / batchSize)
@@ -86,9 +86,8 @@ await Task.Run(() =>
                                                                                    _localFileCollection.Remove(fileInfoInner);
                                                                                }
                                                                                sI.Stop();
-                                                                               Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished batch #{b} with {batch.Count} items after {s.ElapsedMilliseconds} ms", LogType.Scheme);
-                                                                               b++;
-                                                                               sI = null;
+                                                                               Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms", LogType.Scheme);
+                                                                               Interlocked.Increment(ref b);
                                                                            }));
                                    
                                }
@@ -129,7 +128,7 @@ await EnqueueOnDispatcherQueueAsync(() =>
 
             if (ListViewTable.Items.Count < 1000)
             {
-                CheckAll();
+                await CheckAll();
             }
             else
             {
@@ -165,17 +164,19 @@ private async void ToggleCheckAll(object sender, RoutedEventArgs e)
             LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "UI might freeze for a moment...");
             await Task.Delay(100);
             s.Start();
+            bool toCheckCopy = false;
             if (sender is CheckBox checkBox)
             {
                 bool toCheck = checkBox.IsChecked ?? false;
                 await ToggleCheckAllInnerAsync(toCheck);
+                toCheckCopy = toCheck;
             } 
             s.Stop();
             LoadingMessageHelper.HideLoadingFrame();
-            Logger.LogWriteLine("[FileCleanupPage::ToggleCheckAll] Elapsed time: " + s.ElapsedMilliseconds + "ms", LogType.Scheme);
+            Logger.LogWriteLine($"[FileCleanupPage::ToggleCheckAll{toCheckCopy}] Elapsed time: {s.ElapsedMilliseconds} ms", LogType.Scheme);
         }
 
-        private async void CheckAll()
+        private async Task CheckAll()
         {
             await ToggleCheckAllInnerAsync(true);
         }
@@ -184,11 +185,11 @@ private async Task ToggleCheckAllInnerAsync(bool selectAll)
         {
             if (selectAll)
             {
-                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.SelectAll());
+                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.SelectAllSafe());
             }
             else
             {
-                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.SelectedItems.Clear());
+                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.DeselectAll());
             }
         }
 
@@ -369,9 +370,10 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                 await Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted));
                 DispatcherQueue.TryEnqueue(() =>
                                            {
+                                               var toBeDeletedSet = new HashSet<string>(toBeDeleted);
                                                for (int i = FileInfoSource.Count - 1; i >= 0; i--)
                                                {
-                                                   if (toBeDeleted.Contains(FileInfoSource[i].ToFileInfo().FullName))
+                                                   if (toBeDeletedSet.Contains(FileInfoSource[i].FullPath))
                                                    {
                                                        FileInfoSource.RemoveAt(i);
                                                    }
diff --git a/Hi3Helper.EncTool b/Hi3Helper.EncTool
index 2205c3a9a..169d2af77 160000
--- a/Hi3Helper.EncTool
+++ b/Hi3Helper.EncTool
@@ -1 +1 @@
-Subproject commit 2205c3a9a4ca60c4256b3de80fbcd086fbaa9779
+Subproject commit 169d2af77d420595f37818f73f2c981b8975d83e

From d2038b05e9bf88470fc949dcb1e5def13bf91da1 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Fri, 20 Dec 2024 21:16:29 +0700
Subject: [PATCH 07/22] Use .NET's built-in SIMD Sum tool instead on
 ListView_SelectionChanged

Co-authored-by: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 51 +++++--------------
 1 file changed, 12 insertions(+), 39 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index c5ab9f399..2066d866c 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -173,7 +173,7 @@ private async void ToggleCheckAll(object sender, RoutedEventArgs e)
             } 
             s.Stop();
             LoadingMessageHelper.HideLoadingFrame();
-            Logger.LogWriteLine($"[FileCleanupPage::ToggleCheckAll{toCheckCopy}] Elapsed time: {s.ElapsedMilliseconds} ms", LogType.Scheme);
+            Logger.LogWriteLine($"[FileCleanupPage::ToggleCheckAll({toCheckCopy})] Elapsed time: {s.ElapsedMilliseconds} ms", LogType.Scheme);
         }
 
         private async Task CheckAll()
@@ -197,9 +197,18 @@ private async void ListView_SelectionChanged(object sender, SelectionChangedEven
         {
             var removedItems = e.RemovedItems.OfType<LocalFileInfo>().ToList();
             var addedItems   = e.AddedItems.OfType<LocalFileInfo>().ToList();
+            
+            var removedSizeTask = Task.Run(() => removedItems.Count < 512
+                                               ? removedItems.Sum(x => x.FileSize)
+                                               : removedItems.Select(x => x.FileSize).ToArray().Sum());
+
+            var addedSizeTask = Task.Run(() => addedItems.Count < 512
+                                             ? addedItems.Sum(x => x.FileSize)
+                                             : addedItems.Select(x => x.FileSize).ToArray().Sum());
 
-            long removedSize = await Task.Run(() => SumFileSizes(removedItems));
-            long addedSize   = await Task.Run(() => SumFileSizes(addedItems));
+            var results     = await Task.WhenAll(removedSizeTask, addedSizeTask);
+            var removedSize = results[0];
+            var addedSize   = results[1];
 
             _selectedAssetsCount += addedItems.Count - removedItems.Count;
             _assetSelectedSize   += addedSize - removedSize;
@@ -229,42 +238,6 @@ await EnqueueOnDispatcherQueueAsync(() =>
             });
         }
 
-        private long SumFileSizes(List<LocalFileInfo> items)
-        {
-            var vectorSize = Vector<long>.Count;
-            var sumVector  = Vector<long>.Zero;
-
-            int i = 0;
-
-            // Vectorized loop
-            for (; i <= items.Count - vectorSize; i += vectorSize)
-            {
-                var fileSizeArray = new long[vectorSize];
-                for (int j = 0; j < vectorSize; j++)
-                {
-                    fileSizeArray[j] = items[i + j].FileSize;
-                }
-
-                var vector = new Vector<long>(fileSizeArray);
-                sumVector += vector;
-            }
-
-            // Aggregate SIMD results
-            long total = 0;
-            for (int j = 0; j < vectorSize; j++)
-            {
-                total += sumVector[j];
-            }
-
-            // Remainder loop for non-vectorized items
-            for (; i < items.Count; i++)
-            {
-                total += items[i].FileSize;
-            }
-
-            return total;
-        }
-
         private Task EnqueueOnDispatcherQueueAsync(Action action)
         {
             var tcs = new TaskCompletionSource();

From 2a3373c63015ece045273b1f10f91ff21d928508 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Fri, 20 Dec 2024 21:26:01 +0700
Subject: [PATCH 08/22] Localize and tidy up

---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 93 ++++++++++---------
 .../Lang/Locale/LangFileCleanupPage.cs        |  2 +
 Hi3Helper.Core/Lang/en_US.json                |  2 +
 3 files changed, 51 insertions(+), 46 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 2066d866c..08ecf1d55 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -66,10 +66,11 @@ public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
                          .Select((file, index) => new { File = file, Index = index })
                          .GroupBy(x => x.Index / batchSize)
                          .Select(group => group.Select(x => x.File).ToList());
-            var tasks = new List<Task>();
-            Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Starting to inject file info source with {_localFileCollection.Count} items", LogType.Scheme);
             
-            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "TODO: Translate TempAsync1");
+            var tasks = new List<Task>();
+            Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
+                                $"Starting to inject file info source with {_localFileCollection.Count} items",
+                                LogType.Scheme);
 
             int b = 0;
             await Task.Run(() =>
@@ -77,18 +78,21 @@ await Task.Run(() =>
                                foreach (var batch in batches)
                                {
                                    tasks.Add(EnqueueOnDispatcherQueueAsync(() =>
-                                                                           {
-                                                                               var sI = new Stopwatch();
-                                                                               s.Start();
-                                                                               foreach (var fileInfoInner in batch)
-                                                                               {
-                                                                                   FileInfoSource.Add(fileInfoInner);
-                                                                                   _localFileCollection.Remove(fileInfoInner);
-                                                                               }
-                                                                               sI.Stop();
-                                                                               Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms", LogType.Scheme);
-                                                                               Interlocked.Increment(ref b);
-                                                                           }));
+                                   {
+                                       var sI = new Stopwatch();
+                                       s.Start();
+                                       foreach (var fileInfoInner in batch)
+                                       {
+                                           FileInfoSource.Add(fileInfoInner);
+                                           _localFileCollection.Remove(fileInfoInner);
+                                       }
+                                       sI.Stop();
+                                       Logger
+                                          .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
+                                                        $"Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms",
+                                                        LogType.Scheme);
+                                       Interlocked.Increment(ref b);
+                                   }));
                                    
                                }
                            });
@@ -97,22 +101,23 @@ await Task.Run(() =>
             if (_localFileCollection.Count > 0)
             {
                 await EnqueueOnDispatcherQueueAsync(() =>
-                                                    {
-                                                        var i  = 0;
-                                                        var sI = new Stopwatch();
-                                                        sI.Start();
-                                                        while (_localFileCollection.Count > 0)
-                                                        {
-                                                            FileInfoSource.Add(_localFileCollection[0]);
-                                                            _localFileCollection.RemoveAt(0);
-                                                            i++;
-                                                        }
-
-                                                        sI.Stop();
-                                                        Logger
-                                                        .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] Finished last batch at #{b} after {i} items in {sI.ElapsedMilliseconds} ms",
-                                                                        LogType.Scheme);
-                                                    });
+                {
+                    var i  = 0;
+                    var sI = new Stopwatch();
+                    sI.Start();
+                    while (_localFileCollection.Count > 0)
+                    {
+                        FileInfoSource.Add(_localFileCollection[0]);
+                        _localFileCollection.RemoveAt(0);
+                        i++;
+                    }
+
+                    sI.Stop();
+                    Logger
+                    .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
+                                  $"Finished last batch at #{b} after {i} items in {sI.ElapsedMilliseconds} ms",
+                                    LogType.Scheme);
+                });
             }
 
             while (_localFileCollection.Count != 0)
@@ -125,17 +130,7 @@ await EnqueueOnDispatcherQueueAsync(() =>
             await DispatcherQueue.EnqueueAsync(() => UpdateUIOnCollectionChange(FileInfoSource, null));
             s.Stop();
             Logger.LogWriteLine($"InjectFileInfoSource done after {s.ElapsedMilliseconds} ms", LogType.Scheme);
-
-            if (ListViewTable.Items.Count < 1000)
-            {
-                await CheckAll();
-            }
-            else
-            {
-                ToggleCheckAllCheckBox.Content = Locale.Lang._FileCleanupPage.BottomCheckboxNoFileSelected;
-                DeleteSelectedFilesText.Text =
-                    string.Format(Locale.Lang._FileCleanupPage.BottomButtonDeleteSelectedFiles, 0);
-            }
+            await CheckAll();
         }
 
         private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedEventArgs? args)
@@ -159,9 +154,14 @@ private void UpdateUIOnCollectionChange(object? sender, NotifyCollectionChangedE
         private async void ToggleCheckAll(object sender, RoutedEventArgs e)
         {
             var s = new Stopwatch();
-            LoadingMessageHelper.Initialize();
-            LoadingMessageHelper.ShowLoadingFrame();
-            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "UI might freeze for a moment...");
+            if (ListViewTable.Items.Count > 1000)
+            {
+                LoadingMessageHelper.Initialize();
+                LoadingMessageHelper.ShowLoadingFrame();
+                LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle,
+                                                Locale.Lang._FileCleanupPage.LoadingSubtitle3);
+            }
+            
             await Task.Delay(100);
             s.Start();
             bool toCheckCopy = false;
@@ -314,7 +314,8 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                 return;
             }
 
-            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle, "TODO: Translate - Deleting files...");
+            LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle,
+                                            Locale.Lang._FileCleanupPage.DeleteSubtitle);
             LoadingMessageHelper.ShowLoadingFrame();
             
             if (isToRecycleBin)
diff --git a/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs b/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs
index ee12fa153..90c334891 100644
--- a/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs
+++ b/Hi3Helper.Core/Lang/Locale/LangFileCleanupPage.cs
@@ -20,6 +20,8 @@ public sealed partial class LangFileCleanupPage
                 public string LoadingTitle { get; set; } = LangFallback?._FileCleanupPage.LoadingTitle;
                 public string LoadingSubtitle1 { get; set; } = LangFallback?._FileCleanupPage.LoadingSubtitle1;
                 public string LoadingSubtitle2 { get; set; } = LangFallback?._FileCleanupPage.LoadingSubtitle2;
+                public string LoadingSubtitle3 { get; set; } = LangFallback?._FileCleanupPage.LoadingSubtitle3;
+                public string DeleteSubtitle { get; set; } = LangFallback?._FileCleanupPage.DeleteSubtitle;
                 public string BottomButtonDeleteAllFiles { get; set; } = LangFallback?._FileCleanupPage.BottomButtonDeleteAllFiles;
                 public string BottomButtonDeleteSelectedFiles { get; set; } = LangFallback?._FileCleanupPage.BottomButtonDeleteSelectedFiles;
                 public string BottomCheckboxFilesSelected { get; set; } = LangFallback?._FileCleanupPage.BottomCheckboxFilesSelected;
diff --git a/Hi3Helper.Core/Lang/en_US.json b/Hi3Helper.Core/Lang/en_US.json
index f49bcd46e..b80622db6 100644
--- a/Hi3Helper.Core/Lang/en_US.json
+++ b/Hi3Helper.Core/Lang/en_US.json
@@ -1451,6 +1451,8 @@
     "LoadingTitle": "Processing",
     "LoadingSubtitle1": "Calculating Existing Files ({0} file(s) found - {1} in total)...",
     "LoadingSubtitle2": "Checking pkg_version's availability...",
+    "LoadingSubtitle3": "UI might be unresponsive during this process...",
+    "DeleteSubtitle": "Deleting files...",
     "BottomButtonDeleteAllFiles": "Delete All Files",
     "BottomButtonDeleteSelectedFiles": "Delete {0} Selected File(s)",
     "BottomCheckboxFilesSelected": "{0} File(s) Selected ({1} / {2} Total)",

From 699e1f7fc5e4c6223387f0d1d81e0d09d4b332b8 Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Fri, 20 Dec 2024 21:30:38 +0700
Subject: [PATCH 09/22] Revert "Merge remote-tracking branch
 'origin/zzz-mobile-mode' into filecleanup-improvement"

This reverts commit 474422f011d45ddfb93b7d03375cb6df1d740815, reversing
changes made to 32c6cae2f350a20b9fb51f21cc8d6ca171785ba9.
---
 .../ZenlessGameSettingsPage.Ext.cs                  | 13 ++-----------
 .../GameSettingsPages/ZenlessGameSettingsPage.xaml  |  4 +++-
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs
index 96f7239f5..f818e7673 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.Ext.cs
@@ -310,17 +310,8 @@ public bool IsGameBoost
         
         public bool IsMobileMode
         {
-            get
-            {
-                var cSet = Settings?.SettingsCollapseMisc?.LaunchMobileMode ?? false;
-                var gSet = Settings.GeneralData.LocalUILayoutPlatform == 1;
-                return cSet || gSet;
-            }
-            set
-            {
-                Settings.SettingsCollapseMisc.LaunchMobileMode = value;
-                Settings.GeneralData.LocalUILayoutPlatform     = value ? 1 : 3;
-            }
+            get => Settings?.SettingsCollapseMisc?.LaunchMobileMode ?? false;
+            set => Settings.SettingsCollapseMisc.LaunchMobileMode = value;
         }
         #endregion
 
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml
index 4d68b72d6..c3f4ffc23 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/GameSettingsPages/ZenlessGameSettingsPage.xaml
@@ -164,7 +164,9 @@
                                             <CheckBox x:Name="MobileModeToggle"
                                                       HorizontalAlignment="Left"
                                                       VerticalAlignment="Center"
-                                                      IsChecked="{x:Bind IsMobileMode, Mode=TwoWay}">
+                                                      IsChecked="{x:Bind IsMobileMode, Mode=TwoWay}"
+                                                      IsEnabled="False"
+                                                      Visibility="Collapsed">
                                                 <TextBlock Text="{x:Bind helper:Locale.Lang._GameSettingsPage.MobileLayout}"
                                                            TextWrapping="Wrap" />
                                             </CheckBox>

From 7b139bc86a98b5668a17467dd00c45fd0ee1b0ea Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 16:52:47 +0700
Subject: [PATCH 10/22] Remove unnecessary refresh on FileInfo.EnsureNoReadOnly

---
 CollapseLauncher/Classes/Helper/StreamUtility.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CollapseLauncher/Classes/Helper/StreamUtility.cs b/CollapseLauncher/Classes/Helper/StreamUtility.cs
index cae294b80..07dd14d74 100644
--- a/CollapseLauncher/Classes/Helper/StreamUtility.cs
+++ b/CollapseLauncher/Classes/Helper/StreamUtility.cs
@@ -55,7 +55,6 @@ internal static FileInfo EnsureNoReadOnly(this FileInfo fileInfo)
                 return fileInfo;
 
             fileInfo.IsReadOnly = false;
-            fileInfo.Refresh();
 
             return fileInfo;
         }

From 19b095932bfe421a93484a97100a182cfdfac1e0 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 18:55:24 +0700
Subject: [PATCH 11/22] Reduce memory allocation on RecycleBin tool

---
 Hi3Helper.Win32 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Hi3Helper.Win32 b/Hi3Helper.Win32
index 03bb7e91a..b3e44ad3b 160000
--- a/Hi3Helper.Win32
+++ b/Hi3Helper.Win32
@@ -1 +1 @@
-Subproject commit 03bb7e91ad91303e06a3141b82faaa7d44517dc9
+Subproject commit b3e44ad3bd5f361906fd64f021ccc3f4c3987eea

From 2d9d3eede61fd8474898f255633fbc1139634644 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 18:56:23 +0700
Subject: [PATCH 12/22] [Perf] Improve after-deletion item removal on
 FileInfoSource

---
 .../ObservableCollectionExtension.cs          |  83 +++++++++
 ...mentExtensions.UnsafeAccessorExtensions.cs |  32 ++++
 .../Classes/Extension/UIElementExtensions.cs  |  22 +--
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 159 ++++++++----------
 4 files changed, 190 insertions(+), 106 deletions(-)
 create mode 100644 CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
 create mode 100644 CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs

diff --git a/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs b/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
new file mode 100644
index 000000000..136e3c236
--- /dev/null
+++ b/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Runtime.CompilerServices;
+
+namespace CollapseLauncher.Extension
+{
+    /// <summary>
+    /// Provides extension methods for <see cref="ObservableCollection{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the collection.</typeparam>
+    internal static class ObservableCollectionExtension<T>
+    {
+        /// <summary>
+        /// Gets the backing list of the specified collection.
+        /// </summary>
+        /// <param name="source">The collection to get the backing list from.</param>
+        /// <returns>A reference to the backing list of the collection.</returns>
+        [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "items")]
+        internal static extern ref IList<T> GetBackedCollectionList(Collection<T> source);
+
+        /// <summary>
+        /// Invokes the OnCountPropertyChanged method on the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "OnCountPropertyChanged")]
+        internal static extern void OnCountPropertyChanged(ObservableCollection<T> source);
+
+        /// <summary>
+        /// Invokes the OnIndexerPropertyChanged method on the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "OnIndexerPropertyChanged")]
+        internal static extern void OnIndexerPropertyChanged(ObservableCollection<T> source);
+
+        /// <summary>
+        /// Invokes the OnCollectionChanged method on the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        /// <param name="e">The event arguments for the collection changed event.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "OnCollectionChanged")]
+        internal static extern void OnCollectionChanged(ObservableCollection<T> source, NotifyCollectionChangedEventArgs e);
+
+        /// <summary>
+        /// Refreshes all events for the specified observable collection.
+        /// </summary>
+        /// <param name="source">The observable collection to invoke the method on.</param>
+        internal static void RefreshAllEvents(ObservableCollection<T> source)
+        {
+            OnCountPropertyChanged(source);
+            OnIndexerPropertyChanged(source);
+            OnCollectionChanged(source, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+        }
+
+        /// <summary>
+        /// Removes a range of items from the specified observable collection quickly.
+        /// </summary>
+        /// <param name="sourceRange">The list of items to remove from the target collection.</param>
+        /// <param name="target">The observable collection from which the items will be removed.</param>
+        /// <exception cref="InvalidCastException">Thrown when the backing list of the target collection cannot be cast to a List{T}.</exception>
+        /// <remarks>
+        /// This method directly manipulates the backing list of the observable collection to remove the specified items,
+        /// and then fires the necessary property changed and collection changed events to update any bindings.
+        /// </remarks>
+        internal static void RemoveItemsFast(List<T> sourceRange, ObservableCollection<T> target)
+        {
+            // Get the backed list instance of the collection
+            List<T> targetBackedList = GetBackedCollectionList(target) as List<T> ?? throw new InvalidCastException();
+
+            // Get the count and iterate the reference of the T from the source range
+            int len = sourceRange.Count - 1;
+            for (; len >= 0; len--)
+            {
+                // Remove the reference of the item T from the target backed list
+                _ = targetBackedList.Remove(sourceRange[len]);
+            }
+
+            // Fire the changes event
+            RefreshAllEvents(target);
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs b/CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs
new file mode 100644
index 000000000..55ab1f3dc
--- /dev/null
+++ b/CollapseLauncher/Classes/Extension/UIElementExtensions.UnsafeAccessorExtensions.cs
@@ -0,0 +1,32 @@
+using Microsoft.UI.Input;
+using Microsoft.UI.Xaml;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Runtime.CompilerServices;
+
+#nullable enable
+namespace CollapseLauncher.Extension
+{
+    internal static partial class UIElementExtensions
+    {
+        /// <summary>
+        /// Set the cursor for the element.
+        /// </summary>
+        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
+        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
+        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_ProtectedCursor")]
+        internal static extern void SetCursor(this UIElement element, InputCursor inputCursor);
+
+        /// <summary>
+        /// Set the cursor for the element.
+        /// </summary>
+        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
+        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
+        internal static ref T WithCursor<T>(this T element, InputCursor inputCursor) where T : UIElement
+        {
+            element.SetCursor(inputCursor);
+            return ref Unsafe.AsRef(ref element);
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/Extension/UIElementExtensions.cs b/CollapseLauncher/Classes/Extension/UIElementExtensions.cs
index 3a9e860fe..7727673f7 100644
--- a/CollapseLauncher/Classes/Extension/UIElementExtensions.cs
+++ b/CollapseLauncher/Classes/Extension/UIElementExtensions.cs
@@ -18,6 +18,7 @@
 using Windows.UI;
 using Windows.UI.Text;
 using Hi3Helper.SentryHelper;
+using System.Collections.ObjectModel;
 
 namespace CollapseLauncher.Extension
 {
@@ -28,27 +29,8 @@ internal class NavigationViewItemLocaleTextProperty
         public string LocalePropertyName { get; set; }
     }
 
-    internal static class UIElementExtensions
+    internal static partial class UIElementExtensions
     {
-        /// <summary>
-        /// Set the cursor for the element.
-        /// </summary>
-        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
-        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
-        [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_ProtectedCursor")]
-        internal static extern void SetCursor(this UIElement element, InputCursor inputCursor);
-
-        /// <summary>
-        /// Set the cursor for the element.
-        /// </summary>
-        /// <param name="element">The <seealso cref="UIElement"/> member of an element</param>
-        /// <param name="inputCursor">The cursor you want to set. Use <see cref="InputSystemCursor.Create"/> to choose the cursor you want to set.</param>
-        internal static ref T WithCursor<T>(this T element, InputCursor inputCursor) where T : UIElement
-        {
-            element.SetCursor(inputCursor);
-            return ref Unsafe.AsRef(ref element);
-        }
-
 #nullable enable
         /// <summary>
         /// Set the initial navigation view item's locale binding before getting set with <seealso cref="ApplyNavigationViewItemLocaleTextBindings"/>
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 08ecf1d55..e2d1424f4 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -1,6 +1,7 @@
 using CollapseLauncher.CustomControls;
 using CollapseLauncher.Dialogs;
 using CollapseLauncher.Extension;
+using CollapseLauncher.Helper;
 using CollapseLauncher.Helper.Loading;
 using CollapseLauncher.InstallManager.Base;
 using CommunityToolkit.WinUI;
@@ -18,7 +19,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -31,11 +32,13 @@ namespace CollapseLauncher.Pages
     public sealed partial class FileCleanupPage
     {
         internal static FileCleanupPage?                    Current { get; set; }
-        internal        ObservableCollection<LocalFileInfo> FileInfoSource = [];
+        internal        ObservableCollection<LocalFileInfo> FileInfoSource;
 
     #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
         public FileCleanupPage()
         {
+            FileInfoSource = new ObservableCollection<LocalFileInfo>();
+
             InitializeComponent();
             Current = this;
             Loaded += (_, _) =>
@@ -50,7 +53,6 @@ public FileCleanupPage()
         private string _assetTotalSizeString = string.Empty;
         private long   _assetSelectedSize;
 
-        private ObservableCollection<LocalFileInfo> _localFileCollection;
         public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
         {
             var s = new Stopwatch();
@@ -58,57 +60,51 @@ public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
             
             FileInfoSource.Clear();
             _assetTotalSize = 0;
+
+            ObservableCollection<LocalFileInfo>  localFileCollection = new ObservableCollection<LocalFileInfo>(fileInfoList);
+            int batchSize = Math.Clamp(localFileCollection.Count / Environment.ProcessorCount, 50, 5000);
             
-            _localFileCollection = new ObservableCollection<LocalFileInfo>(fileInfoList);
-            int batchSize = Math.Clamp(_localFileCollection.Count / Environment.ProcessorCount, 50, 5000);
-            
-            var batches = _localFileCollection
-                         .Select((file, index) => new { File = file, Index = index })
-                         .GroupBy(x => x.Index / batchSize)
-                         .Select(group => group.Select(x => x.File).ToList());
+            IEnumerable<List<LocalFileInfo>> batches = localFileCollection
+                                                      .Select((file, index) => new { File = file, Index = index })
+                                                      .GroupBy(x => x.Index / batchSize)
+                                                      .Select(group => group.Select(x => x.File).ToList());
             
-            var tasks = new List<Task>();
+            List<Task> tasks = [];
             Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
-                                $"Starting to inject file info source with {_localFileCollection.Count} items",
+                                $"Starting to inject file info source with {localFileCollection.Count} items",
                                 LogType.Scheme);
 
             int b = 0;
             await Task.Run(() =>
                            {
-                               foreach (var batch in batches)
-                               {
-                                   tasks.Add(EnqueueOnDispatcherQueueAsync(() =>
-                                   {
-                                       var sI = new Stopwatch();
-                                       s.Start();
-                                       foreach (var fileInfoInner in batch)
-                                       {
-                                           FileInfoSource.Add(fileInfoInner);
-                                           _localFileCollection.Remove(fileInfoInner);
-                                       }
-                                       sI.Stop();
-                                       Logger
-                                          .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
-                                                        $"Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms",
-                                                        LogType.Scheme);
-                                       Interlocked.Increment(ref b);
-                                   }));
-                                   
-                               }
+                               tasks.AddRange(batches.Select(batch => EnqueueOnDispatcherQueueAsync(() =>
+                                                                                                    {
+                                                                                                        var sI = new Stopwatch();
+                                                                                                        s.Start();
+                                                                                                        foreach (var fileInfoInner in batch)
+                                                                                                        {
+                                                                                                            FileInfoSource.Add(fileInfoInner);
+                                                                                                            localFileCollection.Remove(fileInfoInner);
+                                                                                                        }
+
+                                                                                                        sI.Stop();
+                                                                                                        Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " + $"Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms", LogType.Scheme);
+                                                                                                        Interlocked.Increment(ref b);
+                                                                                                    })));
                            });
             await Task.WhenAll(tasks);
 
-            if (_localFileCollection.Count > 0)
+            if (localFileCollection.Count > 0)
             {
                 await EnqueueOnDispatcherQueueAsync(() =>
                 {
                     var i  = 0;
                     var sI = new Stopwatch();
                     sI.Start();
-                    while (_localFileCollection.Count > 0)
+                    while (localFileCollection.Count > 0)
                     {
-                        FileInfoSource.Add(_localFileCollection[0]);
-                        _localFileCollection.RemoveAt(0);
+                        FileInfoSource.Add(localFileCollection[0]);
+                        localFileCollection.RemoveAt(0);
                         i++;
                     }
 
@@ -120,10 +116,10 @@ await EnqueueOnDispatcherQueueAsync(() =>
                 });
             }
 
-            while (_localFileCollection.Count != 0)
+            while (localFileCollection.Count != 0)
             {
-                FileInfoSource.Add(_localFileCollection[0]);
-                _localFileCollection.RemoveAt(0);
+                FileInfoSource.Add(localFileCollection[0]);
+                localFileCollection.RemoveAt(0);
             }
             
             await Task.Run(() => _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize));
@@ -185,11 +181,11 @@ private async Task ToggleCheckAllInnerAsync(bool selectAll)
         {
             if (selectAll)
             {
-                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.SelectAllSafe());
+                await EnqueueOnDispatcherQueueAsync(ListViewTable.SelectAllSafe);
             }
             else
             {
-                await EnqueueOnDispatcherQueueAsync(() => ListViewTable.DeselectAll());
+                await EnqueueOnDispatcherQueueAsync(ListViewTable.DeselectAll);
             }
         }
 
@@ -198,11 +194,11 @@ private async void ListView_SelectionChanged(object sender, SelectionChangedEven
             var removedItems = e.RemovedItems.OfType<LocalFileInfo>().ToList();
             var addedItems   = e.AddedItems.OfType<LocalFileInfo>().ToList();
             
-            var removedSizeTask = Task.Run(() => removedItems.Count < 512
+            var removedSizeTask = Task.Run(() => removedItems.Count == 0 ? 0 : removedItems.Count < 512
                                                ? removedItems.Sum(x => x.FileSize)
                                                : removedItems.Select(x => x.FileSize).ToArray().Sum());
 
-            var addedSizeTask = Task.Run(() => addedItems.Count < 512
+            var addedSizeTask = Task.Run(() => addedItems.Count == 0 ? 0 : addedItems.Count < 512
                                              ? addedItems.Sum(x => x.FileSize)
                                              : addedItems.Select(x => x.FileSize).ToArray().Sum());
 
@@ -266,7 +262,7 @@ private async void DeleteAllFiles_Click(object sender, RoutedEventArgs e)
 
         private async void DeleteSelectedFiles_Click(object sender, RoutedEventArgs e)
         {
-            IList<LocalFileInfo> fileInfoList = ListViewTable.SelectedItems
+            List<LocalFileInfo> fileInfoList = ListViewTable.SelectedItems
                                                              .OfType<LocalFileInfo>()
                                                              .ToList();
             long size = fileInfoList.Sum(x => x.FileSize);
@@ -317,76 +313,67 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
             LoadingMessageHelper.SetMessage(Locale.Lang._FileCleanupPage.LoadingTitle,
                                             Locale.Lang._FileCleanupPage.DeleteSubtitle);
             LoadingMessageHelper.ShowLoadingFrame();
-            
+
+            List<LocalFileInfo> deletedItems = [];
             if (isToRecycleBin)
             {
-                IList<string> toBeDeleted = new List<string>();
-
-                foreach (LocalFileInfo fileInfo in deletionSource)
-                {
-                    try
-                    {
-                        FileInfo fileInfoN = fileInfo.ToFileInfo();
-                        if (fileInfoN.Exists)
-                        {
-                            fileInfoN.IsReadOnly = false;
-                            toBeDeleted.Add(fileInfoN.FullName);
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        ++deleteFailed;
-                        Logger.LogWriteLine($"Failed to remove read only attribute from this file: {fileInfo.FullPath}\r\n{ex}",
-                                            LogType.Error, true);
-                    }
-                }
-
+                // Get the list of the file to be deleted and add it to the deletedItems List if it exists
+                List<string> toBeDeleted = await Task.Run(() => deletionSource
+                                          .Select(x =>
+                                                  {
+                                                      var localFileInfo = x.ToFileInfo().EnsureNoReadOnly();
+                                                      if (!localFileInfo.Exists)
+                                                      {
+                                                          return string.Empty;
+                                                      }
+
+                                                      deletedItems.Add(x);
+                                                      return localFileInfo.FullName;
+                                                  })
+                                          .Where(x => !string.IsNullOrEmpty(x))
+                                          .ToList());
+
+                // Execute the deletion process
                 await Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted));
-                DispatcherQueue.TryEnqueue(() =>
-                                           {
-                                               var toBeDeletedSet = new HashSet<string>(toBeDeleted);
-                                               for (int i = FileInfoSource.Count - 1; i >= 0; i--)
-                                               {
-                                                   if (toBeDeletedSet.Contains(FileInfoSource[i].FullPath))
-                                                   {
-                                                       FileInfoSource.RemoveAt(i);
-                                                   }
-                                               }
-                                           });
-                
                 deleteSuccess = toBeDeleted.Count;
             }
             else
             {
                 ConcurrentDictionary<LocalFileInfo, byte> processedFiles = new();
-                
+
                 var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
                 await Parallel.ForEachAsync(deletionSource, options, async (fileInfo, _) =>
                 {
                     if (!processedFiles.TryAdd(fileInfo, 0))
-                        return;    
+                        return;
 
                     try
                     {
-                        FileInfo fileInfoN = fileInfo.ToFileInfo();
+                        FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly();
                         if (fileInfoN.Exists)
                         {
-                            fileInfoN.IsReadOnly = false;
+                            deletedItems.Add(fileInfo);
                             fileInfoN.Delete();
                         }
 
-                        await EnqueueOnDispatcherQueueAsync(() => FileInfoSource.Remove(fileInfo));
                         Interlocked.Increment(ref deleteSuccess);
                     }
                     catch (Exception ex)
                     {
-                     Interlocked.Increment(ref deleteFailed);
-                     Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
-                                         LogType.Error, true);
+                        Interlocked.Increment(ref deleteFailed);
+                        Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
+                                            LogType.Error, true);
                     }
                 });
             }
 
+            // Execute the deleted items removal from the source collection with our own method (which is ridiculously faster).
+            // For god sake, MSFT. We hope a better to delete all these items in one go.
+            // The current implementation is reaaaaallllyyyy slooowwwwwww.
+            await EnqueueOnDispatcherQueueAsync(() =>
+                ObservableCollectionExtension<LocalFileInfo>
+                    .RemoveItemsFast(deletedItems, FileInfoSource));
+
             string diagTitle = dialogResult == ContentDialogResult.Primary
                 ? Locale.Lang._FileCleanupPage.DialogDeleteSuccessTitle
                 : Locale.Lang._FileCleanupPage.DialogTitleMovedToRecycleBin;

From 19b66d8488948b4d673357445ee45d70058e9ad5 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 19:12:05 +0700
Subject: [PATCH 13/22] [Perf] Improve LocalFileInfo injection process

---
 .../ObservableCollectionExtension.cs          |  6 +++--
 .../Classes/Helper/StreamUtility.cs           |  5 +++-
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 25 +++++++++++--------
 3 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs b/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
index 136e3c236..9e3f0f39b 100644
--- a/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
+++ b/CollapseLauncher/Classes/Extension/ObservableCollectionExtension.cs
@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace CollapseLauncher.Extension
 {
@@ -69,11 +70,12 @@ internal static void RemoveItemsFast(List<T> sourceRange, ObservableCollection<T
             List<T> targetBackedList = GetBackedCollectionList(target) as List<T> ?? throw new InvalidCastException();
 
             // Get the count and iterate the reference of the T from the source range
-            int len = sourceRange.Count - 1;
+            ReadOnlySpan<T> sourceRangeSpan = CollectionsMarshal.AsSpan(sourceRange);
+            int len = sourceRangeSpan.Length - 1;
             for (; len >= 0; len--)
             {
                 // Remove the reference of the item T from the target backed list
-                _ = targetBackedList.Remove(sourceRange[len]);
+                _ = targetBackedList.Remove(sourceRangeSpan[len]);
             }
 
             // Fire the changes event
diff --git a/CollapseLauncher/Classes/Helper/StreamUtility.cs b/CollapseLauncher/Classes/Helper/StreamUtility.cs
index 07dd14d74..7b932743a 100644
--- a/CollapseLauncher/Classes/Helper/StreamUtility.cs
+++ b/CollapseLauncher/Classes/Helper/StreamUtility.cs
@@ -50,8 +50,11 @@ private static void EnsureFilePathExist([NotNull] string? path)
         */
 
         internal static FileInfo EnsureNoReadOnly(this FileInfo fileInfo)
+            => fileInfo.EnsureNoReadOnly(out _);
+
+        internal static FileInfo EnsureNoReadOnly(this FileInfo fileInfo, out bool isFileExist)
         {
-            if (!fileInfo.Exists)
+            if (!(isFileExist = fileInfo.Exists))
                 return fileInfo;
 
             fileInfo.IsReadOnly = false;
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index e2d1424f4..793eb42aa 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -59,9 +59,12 @@ public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
             s.Start();
             
             FileInfoSource.Clear();
+            List<LocalFileInfo> backedFileInfoSourceList = ObservableCollectionExtension<LocalFileInfo>
+                .GetBackedCollectionList(FileInfoSource) as List<LocalFileInfo> ?? throw new InvalidCastException();
+
             _assetTotalSize = 0;
 
-            ObservableCollection<LocalFileInfo>  localFileCollection = new ObservableCollection<LocalFileInfo>(fileInfoList);
+            List<LocalFileInfo> localFileCollection = [..fileInfoList];
             int batchSize = Math.Clamp(localFileCollection.Count / Environment.ProcessorCount, 50, 5000);
             
             IEnumerable<List<LocalFileInfo>> batches = localFileCollection
@@ -103,7 +106,7 @@ await EnqueueOnDispatcherQueueAsync(() =>
                     sI.Start();
                     while (localFileCollection.Count > 0)
                     {
-                        FileInfoSource.Add(localFileCollection[0]);
+                        backedFileInfoSourceList.Add(localFileCollection[0]);
                         localFileCollection.RemoveAt(0);
                         i++;
                     }
@@ -118,10 +121,12 @@ await EnqueueOnDispatcherQueueAsync(() =>
 
             while (localFileCollection.Count != 0)
             {
-                FileInfoSource.Add(localFileCollection[0]);
+                backedFileInfoSourceList.Add(localFileCollection[0]);
                 localFileCollection.RemoveAt(0);
             }
-            
+
+            ObservableCollectionExtension<LocalFileInfo>.RefreshAllEvents(FileInfoSource);
+
             await Task.Run(() => _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize));
             await DispatcherQueue.EnqueueAsync(() => UpdateUIOnCollectionChange(FileInfoSource, null));
             s.Stop();
@@ -254,7 +259,7 @@ private Task EnqueueOnDispatcherQueueAsync(Action action)
 
         private async void DeleteAllFiles_Click(object sender, RoutedEventArgs e)
         {
-            IList<LocalFileInfo> fileInfoList = FileInfoSource
+            List<LocalFileInfo> fileInfoList = FileInfoSource
                .ToList();
             long size = fileInfoList.Sum(x => x.FileSize);
             await PerformRemoval(fileInfoList, size);
@@ -269,7 +274,7 @@ private async void DeleteSelectedFiles_Click(object sender, RoutedEventArgs e)
             await PerformRemoval(fileInfoList, size);
         }
 
-        private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, long totalSize)
+        private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long totalSize)
         {
             if (deletionSource == null)
             {
@@ -321,8 +326,8 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                 List<string> toBeDeleted = await Task.Run(() => deletionSource
                                           .Select(x =>
                                                   {
-                                                      var localFileInfo = x.ToFileInfo().EnsureNoReadOnly();
-                                                      if (!localFileInfo.Exists)
+                                                      var localFileInfo = x.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
+                                                      if (!isFileExist)
                                                       {
                                                           return string.Empty;
                                                       }
@@ -331,10 +336,10 @@ private async Task PerformRemoval(ICollection<LocalFileInfo>? deletionSource, lo
                                                       return localFileInfo.FullName;
                                                   })
                                           .Where(x => !string.IsNullOrEmpty(x))
-                                          .ToList());
+                                          .ToList()).ConfigureAwait(false);
 
                 // Execute the deletion process
-                await Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted));
+                await Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted)).ConfigureAwait(false);
                 deleteSuccess = toBeDeleted.Count;
             }
             else

From 314c21a0e0eff85d7918ee67e461a0ee4e257f93 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 19:12:55 +0700
Subject: [PATCH 14/22] [Perf] Detach thread on normal deletion

---
 .../XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs           | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 793eb42aa..15b95076d 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -347,15 +347,15 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                 ConcurrentDictionary<LocalFileInfo, byte> processedFiles = new();
 
                 var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
-                await Parallel.ForEachAsync(deletionSource, options, async (fileInfo, _) =>
+                await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
                 {
                     if (!processedFiles.TryAdd(fileInfo, 0))
                         return;
 
                     try
                     {
-                        FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly();
-                        if (fileInfoN.Exists)
+                        FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
+                        if (isFileExist)
                         {
                             deletedItems.Add(fileInfo);
                             fileInfoN.Delete();
@@ -369,7 +369,7 @@ await Parallel.ForEachAsync(deletionSource, options, async (fileInfo, _) =>
                         Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
                                             LogType.Error, true);
                     }
-                });
+                })).ConfigureAwait(false);
             }
 
             // Execute the deleted items removal from the source collection with our own method (which is ridiculously faster).

From 0e7b8457a85ec411e67187e58a0db28ea0005221 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 19:48:07 +0700
Subject: [PATCH 15/22] Catch exceptions on deletion method

---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 190 ++++++++++--------
 Hi3Helper.Win32                               |   2 +-
 2 files changed, 109 insertions(+), 83 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 15b95076d..cd05a0414 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -7,6 +7,7 @@
 using CommunityToolkit.WinUI;
 using Hi3Helper;
 using Hi3Helper.Data;
+using Hi3Helper.SentryHelper;
 using Hi3Helper.Win32.Native.ManagedTools;
 using Microsoft.UI.Text;
 using Microsoft.UI.Xaml;
@@ -19,7 +20,6 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -282,17 +282,18 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
             }
 
             TextBlock textBlockMsg = new TextBlock
-                {
-                    TextAlignment = TextAlignment.Center,
-                    TextWrapping  = TextWrapping.WrapWholeWords
-                }.AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle1, true)
-                 .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle2, deletionSource.Count),
-                                   true, FontWeights.Medium)
-                 .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle3, true)
-                 .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle4, ConverterTool.SummarizeSizeSimple(totalSize)),
-                                   FontWeights.Medium)
-                 .AddTextBlockNewLine()
-                 .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle5);
+            {
+                TextAlignment = TextAlignment.Center,
+                TextWrapping = TextWrapping.WrapWholeWords
+            }
+            .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle1, true)
+            .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle2, deletionSource.Count),
+                              true, FontWeights.Medium)
+            .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle3, true)
+            .AddTextBlockLine(string.Format(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle4, ConverterTool.SummarizeSizeSimple(totalSize)),
+                              FontWeights.Medium)
+            .AddTextBlockNewLine()
+            .AddTextBlockLine(Locale.Lang._FileCleanupPage.DialogDeletingFileSubtitle5);
 
             ContentDialogResult dialogResult = await SimpleDialogs.SpawnDialog(
                                                                                Locale.Lang._FileCleanupPage
@@ -307,7 +308,7 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                                                                                ContentDialogTheme.Warning);
 
             int deleteSuccess = 0;
-            int deleteFailed  = 0;
+            int deleteFailed = 0;
 
             bool isToRecycleBin = dialogResult == ContentDialogResult.Secondary;
             if (dialogResult == ContentDialogResult.None)
@@ -319,85 +320,110 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                                             Locale.Lang._FileCleanupPage.DeleteSubtitle);
             LoadingMessageHelper.ShowLoadingFrame();
 
-            List<LocalFileInfo> deletedItems = [];
-            if (isToRecycleBin)
-            {
-                // Get the list of the file to be deleted and add it to the deletedItems List if it exists
-                List<string> toBeDeleted = await Task.Run(() => deletionSource
-                                          .Select(x =>
-                                                  {
-                                                      var localFileInfo = x.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
-                                                      if (!isFileExist)
-                                                      {
-                                                          return string.Empty;
-                                                      }
-
-                                                      deletedItems.Add(x);
-                                                      return localFileInfo.FullName;
-                                                  })
-                                          .Where(x => !string.IsNullOrEmpty(x))
-                                          .ToList()).ConfigureAwait(false);
-
-                // Execute the deletion process
-                await Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted)).ConfigureAwait(false);
-                deleteSuccess = toBeDeleted.Count;
-            }
-            else
+            try
             {
-                ConcurrentDictionary<LocalFileInfo, byte> processedFiles = new();
-
-                var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
-                await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
+                List<LocalFileInfo> deletedItems = [];
+                if (isToRecycleBin)
                 {
-                    if (!processedFiles.TryAdd(fileInfo, 0))
-                        return;
+                    // Get the list of the file to be deleted and add it to the deletedItems List if it exists
+                    List<string> toBeDeleted = await Task.Run(() => deletionSource
+                                                                   .Select(x =>
+                                                                           {
+                                                                               var localFileInfo = x.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
+                                                                               if (!isFileExist)
+                                                                               {
+                                                                                   return string.Empty;
+                                                                               }
+
+                                                                               deletedItems.Add(x);
+                                                                               return localFileInfo.FullName;
+                                                                           })
+                                                                   .Where(x => !string.IsNullOrEmpty(x))
+                                                                   .ToList()).ConfigureAwait(false);
 
                     try
                     {
-                        FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
-                        if (isFileExist)
-                        {
-                            deletedItems.Add(fileInfo);
-                            fileInfoN.Delete();
-                        }
 
-                        Interlocked.Increment(ref deleteSuccess);
+                        // Execute the deletion process
+                        var recycleBinTask = Task.Run(() => RecycleBin.MoveFileToRecycleBin(toBeDeleted, true));
+                        await recycleBinTask.ConfigureAwait(false);
+
+                        deleteSuccess = toBeDeleted.Count;
                     }
-                    catch (Exception ex)
+                    catch (OperationCanceledException)
                     {
-                        Interlocked.Increment(ref deleteFailed);
-                        Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
-                                            LogType.Error, true);
+                        Logger.LogWriteLine($"The deletion to Recycle Bin was cancelled!",
+                                            LogType.Warning, true);
+                        toBeDeleted.Clear();
                     }
-                })).ConfigureAwait(false);
-            }
+                }
+                else
+                {
+                    ConcurrentDictionary<LocalFileInfo, byte> processedFiles = new();
 
-            // Execute the deleted items removal from the source collection with our own method (which is ridiculously faster).
-            // For god sake, MSFT. We hope a better to delete all these items in one go.
-            // The current implementation is reaaaaallllyyyy slooowwwwwww.
-            await EnqueueOnDispatcherQueueAsync(() =>
-                ObservableCollectionExtension<LocalFileInfo>
-                    .RemoveItemsFast(deletedItems, FileInfoSource));
-
-            string diagTitle = dialogResult == ContentDialogResult.Primary
-                ? Locale.Lang._FileCleanupPage.DialogDeleteSuccessTitle
-                : Locale.Lang._FileCleanupPage.DialogTitleMovedToRecycleBin;
-
-            await SimpleDialogs.SpawnDialog(diagTitle,
-                                            string.Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle1,
-                                                          deleteSuccess)
-                                            + (deleteFailed == 0
-                                                ? string.Empty
-                                                : ' ' +
-                                                  string
-                                                     .Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle2,
-                                                             deleteFailed)),
-                                            this,
-                                            Locale.Lang._Misc.OkayHappy,
-                                            null,
-                                            null,
-                                            ContentDialogButton.Close,
-                                            ContentDialogTheme.Success);
+                    var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
+                    await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
+                    {
+                        if (!processedFiles.TryAdd(fileInfo, 0))
+                            return;
+
+                        try
+                        {
+                            FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
+                            if (isFileExist)
+                            {
+                                deletedItems.Add(fileInfo);
+                                fileInfoN.Delete();
+                            }
+
+                            Interlocked.Increment(ref deleteSuccess);
+                        }
+                        catch (Exception ex)
+                        {
+                            Interlocked.Increment(ref deleteFailed);
+                            Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
+                                                LogType.Error, true);
+                        }
+                    })).ConfigureAwait(false);
+                }
+
+                // Execute the deleted items removal from the source collection with our own method (which is ridiculously faster).
+                // For god sake, MSFT. We hope a better to delete all these items in one go.
+                // The current implementation is reaaaaallllyyyy slooowwwwwww.
+                await EnqueueOnDispatcherQueueAsync(() =>
+                    ObservableCollectionExtension<LocalFileInfo>
+                        .RemoveItemsFast(deletedItems, FileInfoSource));
+
+                string diagTitle = dialogResult == ContentDialogResult.Primary
+                    ? Locale.Lang._FileCleanupPage.DialogDeleteSuccessTitle
+                    : Locale.Lang._FileCleanupPage.DialogTitleMovedToRecycleBin;
+
+                await SimpleDialogs.SpawnDialog(diagTitle,
+                                                string.Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle1,
+                                                              deleteSuccess)
+                                                + (deleteFailed == 0
+                                                    ? string.Empty
+                                                    : ' ' +
+                                                      string
+                                                         .Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle2,
+                                                                 deleteFailed)),
+                                                this,
+                                                Locale.Lang._Misc.OkayHappy,
+                                                null,
+                                                null,
+                                                ContentDialogButton.Close,
+                                                ContentDialogTheme.Success);
+            }
+            catch (Exception ex)
+            {
+                await SentryHelper.ExceptionHandlerAsync(ex);
+                Logger.LogWriteLine($"Failed while deleting to Recycle Bin: {ex}",
+                                    LogType.Error, true);
+            }
+            finally
+            {
+                LoadingMessageHelper.HideLoadingFrame();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/Hi3Helper.Win32 b/Hi3Helper.Win32
index b3e44ad3b..e74992ff4 160000
--- a/Hi3Helper.Win32
+++ b/Hi3Helper.Win32
@@ -1 +1 @@
-Subproject commit b3e44ad3bd5f361906fd64f021ccc3f4c3987eea
+Subproject commit e74992ff433c5775cca614da9668713c9ea354dd

From 3c5fc36b45786271a0eb67b215194144aaea8684 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 20:02:06 +0700
Subject: [PATCH 16/22] Fix wrong list to reset on cancelled delete

---
 CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index cd05a0414..9cdad331e 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -354,7 +354,7 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                     {
                         Logger.LogWriteLine($"The deletion to Recycle Bin was cancelled!",
                                             LogType.Warning, true);
-                        toBeDeleted.Clear();
+                        deletedItems.Clear();
                     }
                 }
                 else

From 0e724fd9db4ae0bc91455eb16baadcca67c23e36 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 20:03:17 +0700
Subject: [PATCH 17/22] Fix Recycle Bin cancellation not thrown

---
 Hi3Helper.Win32 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Hi3Helper.Win32 b/Hi3Helper.Win32
index e74992ff4..1131f8c12 160000
--- a/Hi3Helper.Win32
+++ b/Hi3Helper.Win32
@@ -1 +1 @@
-Subproject commit e74992ff433c5775cca614da9668713c9ea354dd
+Subproject commit 1131f8c124637847fe0e35eddfd3cbc5b4974e31

From 1e521a940b3b9d1adc9ea1d541cd7e19a9962847 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 20:09:39 +0700
Subject: [PATCH 18/22] Use DispatcherQueue on Show/HideLoadingFrame if
 necessary

---
 .../Helper/Loading/LoadingMessageHelper.cs    | 55 +++++++++++++------
 1 file changed, 39 insertions(+), 16 deletions(-)

diff --git a/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs b/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs
index 7dd9c2aa0..7f68bceac 100644
--- a/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs
+++ b/CollapseLauncher/Classes/Helper/Loading/LoadingMessageHelper.cs
@@ -1,5 +1,6 @@
 using CollapseLauncher.Extension;
 using CollapseLauncher.Helper.Animation;
+using CommunityToolkit.WinUI;
 using CommunityToolkit.WinUI.Animations;
 using Microsoft.UI.Text;
 using Microsoft.UI.Xaml;
@@ -64,28 +65,50 @@ internal static void SetProgressBarState(double maxValue = 100d, bool isProgress
         /// Show the loading frame.
         /// </summary>
         internal static async void ShowLoadingFrame()
+        {
+            if (currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.HasThreadAccess)
+            {
+                await ShowLoadingFrameInner();
+                return;
+            }
+
+            await currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.EnqueueAsync(ShowLoadingFrameInner);
+        }
+
+        private static async Task ShowLoadingFrameInner()
         {
             if (isCurrentlyShow) return;
 
-            isCurrentlyShow = true;
-            currentMainWindow!.LoadingStatusGrid!.Visibility = Visibility.Visible;
+            isCurrentlyShow                                            = true;
+            currentMainWindow!.LoadingStatusGrid!.Visibility           = Visibility.Visible;
             currentMainWindow!.LoadingStatusBackgroundGrid!.Visibility = Visibility.Visible;
 
             TimeSpan duration = TimeSpan.FromSeconds(0.25);
 
             await Task.WhenAll(
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
-                currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0)),
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0,0,currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z)),
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0))
-                );
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
+                                                              currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0)),
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0, 0, currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z)),
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 1, 0))
+                              );
         }
 
         /// <summary>
         /// Hide the loading frame (also hide the action button).
         /// </summary>
         internal static async void HideLoadingFrame()
+        {
+            if (currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.HasThreadAccess)
+            {
+                await HideLoadingFrameInner();
+                return;
+            }
+
+            await currentMainWindow.LoadingStatusBackgroundGrid.DispatcherQueue.EnqueueAsync(HideLoadingFrameInner);
+        }
+
+        private static async Task HideLoadingFrameInner()
         {
             if (!isCurrentlyShow) return;
 
@@ -93,14 +116,14 @@ internal static async void HideLoadingFrame()
 
             TimeSpan duration = TimeSpan.FromSeconds(0.25);
             await Task.WhenAll(
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
-                currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1)),
-                AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0,0,currentMainWindow.LoadingStatusGrid.Translation.Z)),
-                currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1))
-                );
-
-            currentMainWindow.LoadingStatusGrid.Visibility = Visibility.Collapsed;
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusBackgroundGrid, duration,
+                                                              currentMainWindow.LoadingStatusBackgroundGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1)),
+                               AnimationHelper.StartAnimation(currentMainWindow.LoadingStatusGrid, duration,
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateVector3KeyFrameAnimation("Translation", new Vector3(0, (float)(currentMainWindow.LoadingStatusGrid.ActualHeight + 16), currentMainWindow.LoadingStatusGrid.Translation.Z), new Vector3(0, 0, currentMainWindow.LoadingStatusGrid.Translation.Z)),
+                                                              currentMainWindow.LoadingStatusGrid.GetElementCompositor()!.CreateScalarKeyFrameAnimation("Opacity", 0, 1))
+                              );
+
+            currentMainWindow.LoadingStatusGrid.Visibility            = Visibility.Collapsed;
             currentMainWindow.LoadingStatusBackgroundGrid!.Visibility = Visibility.Collapsed;
             HideActionButton();
         }

From 6a8fc6727950ed97ab413c938edb61493c50a0ea Mon Sep 17 00:00:00 2001
From: Bagus Nur Listiyono <dzakibagus@gmail.com>
Date: Sat, 21 Dec 2024 22:05:27 +0700
Subject: [PATCH 19/22] Improve FileCleanupPage methods (again)

1. Use backedFileInfoSourceList on  InjectFileSource so its faster
2. Remove unnecesary iteration on InjectFileSource
3. Use thread*4 when deleting items
---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 78 ++++++++-----------
 1 file changed, 31 insertions(+), 47 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 9cdad331e..b80b8903b 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -1,4 +1,4 @@
-using CollapseLauncher.CustomControls;
+using CollapseLauncher.CustomControls;
 using CollapseLauncher.Dialogs;
 using CollapseLauncher.Extension;
 using CollapseLauncher.Helper;
@@ -49,21 +49,21 @@ public FileCleanupPage()
     #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 
         private int    _selectedAssetsCount;
-        private long   _assetTotalSize;
+        private long   _assetTotalSize = 0;
         private string _assetTotalSizeString = string.Empty;
         private long   _assetSelectedSize;
 
         public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
         {
+            #if DEBUG
             var s = new Stopwatch();
             s.Start();
+            #endif
             
             FileInfoSource.Clear();
             List<LocalFileInfo> backedFileInfoSourceList = ObservableCollectionExtension<LocalFileInfo>
                 .GetBackedCollectionList(FileInfoSource) as List<LocalFileInfo> ?? throw new InvalidCastException();
 
-            _assetTotalSize = 0;
-
             List<LocalFileInfo> localFileCollection = [..fileInfoList];
             int batchSize = Math.Clamp(localFileCollection.Count / Environment.ProcessorCount, 50, 5000);
             
@@ -80,45 +80,26 @@ public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
             int b = 0;
             await Task.Run(() =>
                            {
-                               tasks.AddRange(batches.Select(batch => EnqueueOnDispatcherQueueAsync(() =>
-                                                                                                    {
-                                                                                                        var sI = new Stopwatch();
-                                                                                                        s.Start();
-                                                                                                        foreach (var fileInfoInner in batch)
-                                                                                                        {
-                                                                                                            FileInfoSource.Add(fileInfoInner);
-                                                                                                            localFileCollection.Remove(fileInfoInner);
-                                                                                                        }
-
-                                                                                                        sI.Stop();
-                                                                                                        Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " + $"Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms", LogType.Scheme);
-                                                                                                        Interlocked.Increment(ref b);
-                                                                                                    })));
+                               tasks.AddRange(batches.Select(batch => 
+                                 EnqueueOnDispatcherQueueAsync(() =>
+                                        {
+                                            var sI = new Stopwatch();
+                                            s.Start();
+                                            foreach (var fileInfoInner in batch)
+                                            {
+                                                backedFileInfoSourceList.Add(fileInfoInner);
+                                                localFileCollection.Remove(fileInfoInner);
+                                            }
+
+                                            sI.Stop();
+                                            Logger.LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " + 
+                                                                $"Finished batch #{b} with {batch.Count} items after {sI.ElapsedMilliseconds} ms", LogType.Scheme);
+                                            Interlocked.Increment(ref b);
+                                        })));
                            });
+            
             await Task.WhenAll(tasks);
 
-            if (localFileCollection.Count > 0)
-            {
-                await EnqueueOnDispatcherQueueAsync(() =>
-                {
-                    var i  = 0;
-                    var sI = new Stopwatch();
-                    sI.Start();
-                    while (localFileCollection.Count > 0)
-                    {
-                        backedFileInfoSourceList.Add(localFileCollection[0]);
-                        localFileCollection.RemoveAt(0);
-                        i++;
-                    }
-
-                    sI.Stop();
-                    Logger
-                    .LogWriteLine($"[FileCleanupPage::InjectFileInfoSource] " +
-                                  $"Finished last batch at #{b} after {i} items in {sI.ElapsedMilliseconds} ms",
-                                    LogType.Scheme);
-                });
-            }
-
             while (localFileCollection.Count != 0)
             {
                 backedFileInfoSourceList.Add(localFileCollection[0]);
@@ -129,8 +110,11 @@ await EnqueueOnDispatcherQueueAsync(() =>
 
             await Task.Run(() => _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize));
             await DispatcherQueue.EnqueueAsync(() => UpdateUIOnCollectionChange(FileInfoSource, null));
+            
+            # if DEBUG
             s.Stop();
             Logger.LogWriteLine($"InjectFileInfoSource done after {s.ElapsedMilliseconds} ms", LogType.Scheme);
+            #endif
             await CheckAll();
         }
 
@@ -352,21 +336,20 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                     }
                     catch (OperationCanceledException)
                     {
-                        Logger.LogWriteLine($"The deletion to Recycle Bin was cancelled!",
+                        Logger.LogWriteLine("The deletion to Recycle Bin was cancelled!",
                                             LogType.Warning, true);
                         deletedItems.Clear();
                     }
                 }
                 else
                 {
-                    ConcurrentDictionary<LocalFileInfo, byte> processedFiles = new();
-
-                    var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
+                    var threadCount = Environment.ProcessorCount * 4;
+                    ThreadPool.GetMinThreads(out var workerThreads, out var completionPortThreads);
+                    ThreadPool.SetMinThreads(Math.Max(workerThreads, threadCount),
+                                             Math.Max(completionPortThreads, threadCount));
+                    var options = new ParallelOptions { MaxDegreeOfParallelism = threadCount };
                     await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
                     {
-                        if (!processedFiles.TryAdd(fileInfo, 0))
-                            return;
-
                         try
                         {
                             FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
@@ -385,6 +368,7 @@ await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
                                                 LogType.Error, true);
                         }
                     })).ConfigureAwait(false);
+                    ThreadPool.SetMinThreads(workerThreads, completionPortThreads);
                 }
 
                 // Execute the deleted items removal from the source collection with our own method (which is ridiculously faster).

From 66dac008e519296d0bf76024d340157f534a73a6 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 22:24:15 +0700
Subject: [PATCH 20/22] Fix inconsistent deletedItems entry

Co-Authored-By: Bagus Nur Listiyono <28079733+bagusnl@users.noreply.github.com>
---
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 31 +++++++++++++++++--
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index b80b8903b..de7d7c19d 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -20,6 +20,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -347,15 +348,24 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                     ThreadPool.GetMinThreads(out var workerThreads, out var completionPortThreads);
                     ThreadPool.SetMinThreads(Math.Max(workerThreads, threadCount),
                                              Math.Max(completionPortThreads, threadCount));
+
                     var options = new ParallelOptions { MaxDegreeOfParallelism = threadCount };
-                    await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
+                    Task deleteListTask = Task.Factory.StartNew(
+                        () => deletedItems.AddRange(CollectionsMarshal.AsSpan(deletionSource)),
+                        CancellationToken.None,
+                        TaskCreationOptions.DenyChildAttach,
+                        TaskScheduler.Default);
+
+                    List<LocalFileInfo> failedList = new List<LocalFileInfo>();
+                    Lock failedListLock = new Lock();
+
+                    Task deleteFileTask = Task.Factory.StartNew(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
                     {
                         try
                         {
                             FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
                             if (isFileExist)
                             {
-                                deletedItems.Add(fileInfo);
                                 fileInfoN.Delete();
                             }
 
@@ -364,10 +374,25 @@ await Task.Run(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
                         catch (Exception ex)
                         {
                             Interlocked.Increment(ref deleteFailed);
+                            lock (failedListLock)
+                            {
+                                failedList.Add(fileInfo);
+                            }
                             Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
                                                 LogType.Error, true);
                         }
-                    })).ConfigureAwait(false);
+                    }));
+
+                    await Task.WhenAll(deleteListTask, deleteFileTask);
+
+                    if (failedList.Count > 0)
+                    {
+                        foreach (LocalFileInfo failedFileInfo in failedList)
+                        {
+                            deletedItems.Remove(failedFileInfo);
+                        }
+                    }
+
                     ThreadPool.SetMinThreads(workerThreads, completionPortThreads);
                 }
 

From 1bda3ecde79072de6d54ec820c88c86c53148b34 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 23:00:52 +0700
Subject: [PATCH 21/22] Another Improvements

+ Initialize deletion file task to fully async with its own thread
+ Log deletion performance
+ Pass _assetTotalSize to the injector method instead of the constructor
---
 .../InstallManagerBase.PkgVersion.cs          | 19 +++--
 .../MainApp/Pages/FileCleanupPage.xaml.cs     | 79 +++++++++++--------
 2 files changed, 58 insertions(+), 40 deletions(-)

diff --git a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
index c01eb37f2..a32aba646 100644
--- a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
+++ b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.PkgVersion.cs
@@ -101,7 +101,7 @@ internal partial class InstallManagerBase
         public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
         {
             // Get the unused file info asynchronously
-            List<LocalFileInfo> unusedFileInfo = await GetUnusedFileInfoList(withDialog);
+            (List<LocalFileInfo>, long) unusedFileInfo = await GetUnusedFileInfoList(withDialog);
             
             // Spawn dialog if used
             if (withDialog)
@@ -116,7 +116,7 @@ public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
                 
                 if (FileCleanupPage.Current == null)
                     return;
-                await FileCleanupPage.Current.InjectFileInfoSource(unusedFileInfo);
+                await FileCleanupPage.Current.InjectFileInfoSource(unusedFileInfo.Item1, unusedFileInfo.Item2);
                 
                 LoadingMessageHelper.HideLoadingFrame();
                 
@@ -132,7 +132,7 @@ public virtual async ValueTask CleanUpGameFiles(bool withDialog = true)
             }
 
             // Delete the file straight forward if dialog is not used
-            foreach (LocalFileInfo fileInfo in unusedFileInfo)
+            foreach (LocalFileInfo fileInfo in unusedFileInfo.Item1)
             {
                 TryDeleteReadOnlyFile(fileInfo.FullPath);
             }
@@ -149,7 +149,7 @@ static void ExitFromOverlay(object? sender, RoutedEventArgs args)
             }
         }
 
-        protected virtual async Task<List<LocalFileInfo>> GetUnusedFileInfoList(bool includeZipCheck)
+        protected virtual async Task<(List<LocalFileInfo>, long)> GetUnusedFileInfoList(bool includeZipCheck)
         {
             LoadingMessageHelper.ShowLoadingFrame();
             try
@@ -282,6 +282,7 @@ await DownloadOtherAudioPkgVersion(_gameAudioLangListPathStatic,
 
                 // Get and filter the unused file from the pkg_versions and ignoredFiles
                 List<LocalFileInfo> unusedFileInfo = [];
+                long unusedFileSize = 0;
                 await Task.Run(() =>
                                    Parallel.ForEach(localFileInfo,
                                                     new ParallelOptions { CancellationToken = _token.Token },
@@ -293,15 +294,19 @@ await Task.Run(() =>
                                                                     ignoredFiles.ToList()))
                                                             return;
 
-                                                        lock (unusedFileInfo) unusedFileInfo.Add(asset);
+                                                        lock (unusedFileInfo)
+                                                        {
+                                                            Interlocked.Add(ref unusedFileSize, asset.FileSize);
+                                                            unusedFileInfo.Add(asset);
+                                                        }
                                                     }));
 
-                return unusedFileInfo;
+                return (unusedFileInfo, unusedFileSize);
             }
             catch (Exception ex)
             {
                 ErrorSender.SendException(ex);
-                return new List<LocalFileInfo>();
+                return (new List<LocalFileInfo>(), 0);
             }
         }
 
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index de7d7c19d..33a8b6abd 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -49,18 +49,18 @@ public FileCleanupPage()
         }
     #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 
-        private int    _selectedAssetsCount;
-        private long   _assetTotalSize = 0;
-        private string _assetTotalSizeString = string.Empty;
-        private long   _assetSelectedSize;
+        private int  _selectedAssetsCount;
+        private long _assetSelectedSize;
+        private long _assetTotalSize;
 
-        public async Task InjectFileInfoSource(IEnumerable<LocalFileInfo> fileInfoList)
+        public async Task InjectFileInfoSource(List<LocalFileInfo> fileInfoList, long assetTotalSize)
         {
             #if DEBUG
             var s = new Stopwatch();
             s.Start();
             #endif
             
+            _assetTotalSize = assetTotalSize;
             FileInfoSource.Clear();
             List<LocalFileInfo> backedFileInfoSourceList = ObservableCollectionExtension<LocalFileInfo>
                 .GetBackedCollectionList(FileInfoSource) as List<LocalFileInfo> ?? throw new InvalidCastException();
@@ -109,7 +109,6 @@ await Task.Run(() =>
 
             ObservableCollectionExtension<LocalFileInfo>.RefreshAllEvents(FileInfoSource);
 
-            await Task.Run(() => _assetTotalSizeString = ConverterTool.SummarizeSizeSimple(_assetTotalSize));
             await DispatcherQueue.EnqueueAsync(() => UpdateUIOnCollectionChange(FileInfoSource, null));
             
             # if DEBUG
@@ -207,7 +206,7 @@ await EnqueueOnDispatcherQueueAsync(() =>
                                                                    Locale.Lang._FileCleanupPage.BottomCheckboxFilesSelected,
                                                                     _selectedAssetsCount,
                                                                     ConverterTool.SummarizeSizeSimple(_assetSelectedSize),
-                                                                    _assetTotalSizeString);
+                                                                    ConverterTool.SummarizeSizeSimple(_assetTotalSize));
                 }
                 else
                 {
@@ -305,6 +304,7 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                                             Locale.Lang._FileCleanupPage.DeleteSubtitle);
             LoadingMessageHelper.ShowLoadingFrame();
 
+            Stopwatch s = Stopwatch.StartNew();
             try
             {
                 List<LocalFileInfo> deletedItems = [];
@@ -337,7 +337,7 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                     }
                     catch (OperationCanceledException)
                     {
-                        Logger.LogWriteLine("The deletion to Recycle Bin was cancelled!",
+                        Logger.LogWriteLine("[FileCleanupPage::PerformRemoval()] The deletion to Recycle Bin was cancelled!",
                                             LogType.Warning, true);
                         deletedItems.Clear();
                     }
@@ -356,11 +356,13 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                         TaskCreationOptions.DenyChildAttach,
                         TaskScheduler.Default);
 
-                    List<LocalFileInfo> failedList = new List<LocalFileInfo>();
+                    List<LocalFileInfo> failedList = [];
                     Lock failedListLock = new Lock();
 
-                    Task deleteFileTask = Task.Factory.StartNew(() => Parallel.ForEach(deletionSource, options, (fileInfo, _) =>
+                    Task deleteFileTask = Parallel.ForEachAsync(deletionSource, options, async (fileInfoState, _) =>
+                    await Task.Factory.StartNew(state =>
                     {
+                        LocalFileInfo fileInfo = (LocalFileInfo)state!;
                         try
                         {
                             FileInfo fileInfoN = fileInfo.ToFileInfo().EnsureNoReadOnly(out bool isFileExist);
@@ -378,10 +380,14 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                             {
                                 failedList.Add(fileInfo);
                             }
-                            Logger.LogWriteLine($"Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
-                                                LogType.Error, true);
+                            Logger.LogWriteLine($"[FileCleanupPage::PerformRemoval()] Failed while deleting this file: {fileInfo.FullPath}\r\n{ex}",
+                                LogType.Error, true);
                         }
-                    }));
+                    },
+                    fileInfoState,
+                    CancellationToken.None,
+                    TaskCreationOptions.DenyChildAttach,
+                    TaskScheduler.Default));
 
                     await Task.WhenAll(deleteListTask, deleteFileTask);
 
@@ -393,6 +399,11 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                         }
                     }
 
+                    long totalDeleted = deletedItems.Select(x => x.FileSize).ToArray().Sum();
+                    _assetTotalSize -= totalDeleted;
+
+                    Logger.LogWriteLine($"[FileCleanupPage::PerformRemoval()] Inner deletion task was completed in: {s.ElapsedMilliseconds} ms", LogType.Scheme);
+
                     ThreadPool.SetMinThreads(workerThreads, completionPortThreads);
                 }
 
@@ -402,26 +413,6 @@ private async Task PerformRemoval(List<LocalFileInfo>? deletionSource, long tota
                 await EnqueueOnDispatcherQueueAsync(() =>
                     ObservableCollectionExtension<LocalFileInfo>
                         .RemoveItemsFast(deletedItems, FileInfoSource));
-
-                string diagTitle = dialogResult == ContentDialogResult.Primary
-                    ? Locale.Lang._FileCleanupPage.DialogDeleteSuccessTitle
-                    : Locale.Lang._FileCleanupPage.DialogTitleMovedToRecycleBin;
-
-                await SimpleDialogs.SpawnDialog(diagTitle,
-                                                string.Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle1,
-                                                              deleteSuccess)
-                                                + (deleteFailed == 0
-                                                    ? string.Empty
-                                                    : ' ' +
-                                                      string
-                                                         .Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle2,
-                                                                 deleteFailed)),
-                                                this,
-                                                Locale.Lang._Misc.OkayHappy,
-                                                null,
-                                                null,
-                                                ContentDialogButton.Close,
-                                                ContentDialogTheme.Success);
             }
             catch (Exception ex)
             {
@@ -432,7 +423,29 @@ await SimpleDialogs.SpawnDialog(diagTitle,
             finally
             {
                 LoadingMessageHelper.HideLoadingFrame();
+                s.Stop();
+                Logger.LogWriteLine($"[FileCleanupPage::PerformRemoval()] The entire deletion task was completed in: {s.ElapsedMilliseconds} ms", LogType.Scheme);
             }
+
+            string diagTitle = dialogResult == ContentDialogResult.Primary
+                ? Locale.Lang._FileCleanupPage.DialogDeleteSuccessTitle
+                : Locale.Lang._FileCleanupPage.DialogTitleMovedToRecycleBin;
+
+            await SimpleDialogs.SpawnDialog(diagTitle,
+                                            string.Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle1,
+                                                          deleteSuccess)
+                                            + (deleteFailed == 0
+                                                ? string.Empty
+                                                : ' ' +
+                                                  string
+                                                     .Format(Locale.Lang._FileCleanupPage.DialogDeleteSuccessSubtitle2,
+                                                             deleteFailed)),
+                                            this,
+                                            Locale.Lang._Misc.OkayHappy,
+                                            null,
+                                            null,
+                                            ContentDialogButton.Close,
+                                            ContentDialogTheme.Success);
         }
     }
 }
\ No newline at end of file

From afc9dd8c2c6e864c374aeeb79918fced305beb52 Mon Sep 17 00:00:00 2001
From: Kemal Setya Adhi <dev.kemalsetyaa@gmail.com>
Date: Sat, 21 Dec 2024 23:04:18 +0700
Subject: [PATCH 22/22] Remove unused namespace :teriderp:

I forgor
---
 CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
index 33a8b6abd..228c8fb96 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/FileCleanupPage.xaml.cs
@@ -13,7 +13,6 @@
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;