Merge pull request #549 from IridiumIO/Version-4.0-Beta6

Version 4.0 beta6

Author: Iridium-IO

.gitignore

@@ -365,4 +365,5 @@ FodyWeavers.xsd
 /CompactGUI/My Project/launchSettings.json
 
 # IntelliJ
-.idea/
+.idea/
+/CompactGUI.WatcherCS

CompactGUI.Core/Analyser.cs

@@ -6,29 +6,66 @@
 
 namespace CompactGUI.Core;
 
-public class Analyser
+public sealed class Analyser : IDisposable
 {
 
     public string FolderName { get; set; }
-    public long UncompressedBytes { get; set; }
-    public long CompressedBytes { get; set; }
-    public bool ContainsCompressedFiles { get; set; }
-    public List<AnalysedFileDetails> FileCompressionDetailsList { get; set; } = new List<AnalysedFileDetails>();
-
     private ILogger<Analyser> _logger;
+    private readonly FolderChangeMonitor _folderMonitor;
+    public bool HasFolderChanged => _folderMonitor.HasChanged;
+    public DateTime LastFolderChanged => _folderMonitor.LastChanged;
+
 
     public Analyser(string folder, ILogger<Analyser> logger)
     {
         FolderName = folder;
-        UncompressedBytes = 0;
-        CompressedBytes = 0;
-        ContainsCompressedFiles = false;
         _logger = logger;
+
+        _folderMonitor = new FolderChangeMonitor(folder);
+        _folderMonitor.Changed += (s, e) =>
+            _logger.LogInformation("Folder change detected by FolderChangeMonitor for {FolderName}", FolderName);
+    }
+
+
+    public long CompressedBytes;
+    public long UncompressedBytes;
+    public bool ContainsCompressedFiles;
+
+    private static long GetTotalCompressedBytes(List<AnalysedFileDetails> fileCompressionDetailsList)
+    {
+        return fileCompressionDetailsList.Sum(f => f.CompressedSize);
+    }
+    private static long GetTotalUncompressedBytes(List<AnalysedFileDetails> fileCompressionDetailsList)
+    {
+        return fileCompressionDetailsList.Sum(f => f.UncompressedSize);
+    }
+    private static bool GetContainsCompressedFiles(List<AnalysedFileDetails> fileCompressionDetailsList)
+    {
+        return fileCompressionDetailsList.Any(f => f.CompressionMode != WOFCompressionAlgorithm.NO_COMPRESSION);
+    }
+
+
+    private List<AnalysedFileDetails>? _analysedFileDetails;
+
+    public async ValueTask<List<AnalysedFileDetails>?> GetAnalysedFilesAsync(CancellationToken token)
+    {
+        if (_analysedFileDetails != null && !HasFolderChanged)
+        {
+            _logger.LogInformation("Returning cached analysed files for folder {FolderName}", FolderName);
+            return _analysedFileDetails;
+        }
+
+        _logger.LogInformation("Analysing folder {FolderName} for the first time or after a change", FolderName);
+        _analysedFileDetails = await AnalyseFolder(token).ConfigureAwait(false);
+        return _analysedFileDetails;
     }
 
 
-    public async Task<Boolean?> AnalyseFolder(CancellationToken cancellationToken)
+    private async Task<List<AnalysedFileDetails>?> AnalyseFolder(CancellationToken cancellationToken)
     {
+
+        List<AnalysedFileDetails>? AnalysedFileDetails;
+
         AnalyserLog.StartingAnalysis(_logger, FolderName);
         Stopwatch sw = Stopwatch.StartNew();
         try
@@ -41,11 +78,7 @@ public Analyser(string folder, ILogger<Analyser> logger)
                 .OfType<AnalysedFileDetails>()
                 .ToList();
 
-            CompressedBytes = fileDetails.Sum(f => f.CompressedSize);
-            UncompressedBytes = fileDetails.Sum(f => f.UncompressedSize);
-            ContainsCompressedFiles = fileDetails.Any(f => f.CompressionMode != WOFCompressionAlgorithm.NO_COMPRESSION);
-
-            FileCompressionDetailsList = fileDetails;
+            AnalysedFileDetails = fileDetails;
         }
         catch (Exception ex)
         {
@@ -54,9 +87,14 @@ public Analyser(string folder, ILogger<Analyser> logger)
         }
         finally { sw.Stop(); }
 
+        _folderMonitor.Reset();
+
+        CompressedBytes = GetTotalCompressedBytes(AnalysedFileDetails);
+        UncompressedBytes = GetTotalUncompressedBytes(AnalysedFileDetails);
+        ContainsCompressedFiles = GetContainsCompressedFiles(AnalysedFileDetails);
         AnalyserLog.AnalysisCompleted(_logger, FolderName, Math.Round(sw.Elapsed.TotalSeconds, 3), CompressedBytes, UncompressedBytes, ContainsCompressedFiles);
 
-        return ContainsCompressedFiles;
+        return AnalysedFileDetails;
 
 
     }
@@ -88,9 +126,9 @@ public Analyser(string folder, ILogger<Analyser> logger)
     public List<ExtensionResult> GetPoorlyCompressedExtensions()
     {
         // Only use PLINQ if the list is large enough to benefit from parallel processing
-        IEnumerable<AnalysedFileDetails> query = FileCompressionDetailsList.Count <= 10000
-            ? FileCompressionDetailsList
-            : FileCompressionDetailsList.AsParallel();
+        IEnumerable<AnalysedFileDetails> query = _analysedFileDetails?.Count <= 10000
+            ? _analysedFileDetails
+            : _analysedFileDetails.AsParallel();
 
         return query
                 .Where(fl => fl.UncompressedSize > 0)
@@ -107,6 +145,11 @@ public List<ExtensionResult> GetPoorlyCompressedExtensions()
 
     }
 
+    public void Dispose()
+    {
+        _folderMonitor.Dispose();
+        _analysedFileDetails?.Clear();
+    }
 }
 
 

CompactGUI.Core/CompactGUI.Core.csproj

@@ -12,12 +12,12 @@
 
 
   <ItemGroup>
+    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
     <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.8" />
     <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.3.183">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="ZLinq" Version="1.4.10" />
   </ItemGroup>
 
 

CompactGUI.Core/Compactor.cs

@@ -11,7 +11,7 @@
 
 namespace CompactGUI.Core;
 
-public class Compactor : ICompressor, IDisposable
+public sealed class Compactor : ICompressor, IDisposable
 {
 
     private readonly string workingDirectory;
@@ -28,12 +28,15 @@ public class Compactor : ICompressor, IDisposable
 
     private ILogger<Compactor> _logger;
 
-    public Compactor(string folderPath, WOFCompressionAlgorithm compressionLevel, string[] excludedFileTypes, ILogger<Compactor>? logger = null)
+    private Analyser _analyser;
+
+    public Compactor(string folderPath, WOFCompressionAlgorithm compressionLevel, string[] excludedFileTypes, Analyser analyser, ILogger<Compactor>? logger = null)
     {
         workingDirectory = folderPath;
         excludedFileExtensions = new HashSet<string>(excludedFileTypes);
         wofCompressionAlgorithm = compressionLevel;
         _logger = logger ?? NullLogger<Compactor>.Instance;
+        _analyser = analyser;
         InitializeCompressionInfoPointer();
     }
 
@@ -122,10 +125,10 @@ public async Task<IEnumerable<FileDetails>> BuildWorkingFilesList()
     {
         uint clusterSize = SharedMethods.GetClusterSize(workingDirectory);
 
-        var analyser = new Analyser(workingDirectory, NullLogger<Analyser>.Instance);
-        var ret = await analyser.AnalyseFolder(cancellationTokenSource.Token);
+        
+        var analysedFiles = await _analyser.GetAnalysedFilesAsync(cancellationTokenSource.Token);
 
-        var filesList = analyser.FileCompressionDetailsList
+        var filesList = analysedFiles?
             .Where(fl =>
                 fl.CompressionMode != wofCompressionAlgorithm
                 && fl.UncompressedSize > clusterSize

CompactGUI.Core/FolderChangeMonitor.cs

@@ -0,0 +1,90 @@
+using System;
+using System.IO;
+using System.Threading;
+
+namespace CompactGUI.Core;
+
+/// <summary>
+/// Monitors a folder (and subfolders) for changes, with debouncing and proper disposal.
+/// </summary>
+public sealed class FolderChangeMonitor : IDisposable
+{
+    private readonly FileSystemWatcher _watcher;
+    private readonly Timer _debounceTimer;
+    private readonly int _debounceMilliseconds;
+    private bool _hasChanged;
+    private DateTime _lastChanged;
+    private bool _disposed;
+
+    /// <summary>
+    /// Raised when the folder has changed (debounced).
+    /// </summary>
+    public event EventHandler? Changed;
+
+    /// <summary>
+    /// True if a change has been detected since the last reset.
+    /// </summary>
+    public bool HasChanged => _hasChanged;
+
+    /// <summary>
+    /// The last time a change was detected.
+    /// </summary>
+    public DateTime LastChanged => _lastChanged;
+
+    /// <summary>
+    /// Create a new FolderChangeMonitor.
+    /// </summary>
+    /// <param name="folderPath">The folder to monitor.</param>
+    /// <param name="debounceMilliseconds">Debounce interval in ms (default: 1000).</param>
+    public FolderChangeMonitor(string folderPath, int debounceMilliseconds = 1000)
+    {
+        _debounceMilliseconds = debounceMilliseconds;
+        _watcher = new FileSystemWatcher(folderPath)
+        {
+            NotifyFilter = NotifyFilters.Size | NotifyFilters.CreationTime | NotifyFilters.LastWrite | NotifyFilters.FileName,
+            IncludeSubdirectories = true,
+            EnableRaisingEvents = true
+        };
+        _watcher.Changed += OnChanged;
+        _watcher.Created += OnChanged;
+        _watcher.Deleted += OnChanged;
+        _watcher.Renamed += OnChanged;
+        _watcher.Error += OnError;
+
+        _debounceTimer = new Timer(DebounceCallback, null, Timeout.Infinite, Timeout.Infinite);
+    }
+
+    private void OnChanged(object sender, FileSystemEventArgs e)
+    {
+        _debounceTimer.Change(_debounceMilliseconds, Timeout.Infinite);
+    }
+
+    private void DebounceCallback(object? state)
+    {
+        _hasChanged = true;
+        _lastChanged = DateTime.Now;
+        Changed?.Invoke(this, EventArgs.Empty);
+    }
+
+    private void OnError(object sender, ErrorEventArgs e)
+    {
+        // Optionally log or handle errors here
+    }
+
+    /// <summary>
+    /// Reset the change flag after handling.
+    /// </summary>
+    public void Reset()
+    {
+        _hasChanged = false;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _watcher.Dispose();
+        _debounceTimer.Dispose();
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

CompactGUI.Core/Settings/ISettingsService.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CompactGUI.Core.Settings
+{
+    public interface ISettingsService
+    {
+
+        DirectoryInfo DataFolder { get; }
+        FileInfo SettingsJSONFile { get; }
+
+        Settings AppSettings { get; set; }
+
+        decimal SettingsVersion { get; }
+
+        void LoadSettings();
+        void SaveSettings();
+        void ScheduleSettingsSave();
+
+
+    }
+
+
+}