readjust cache clean up and add keep originals setting for models

LightlessSync/Services/ModelDecimation/ModelDecimationService.cs

@@ -1,6 +1,8 @@
+using LightlessSync.FileCache;
 using LightlessSync.LightlessConfiguration;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
+using System.Globalization;
 
 namespace LightlessSync.Services.ModelDecimation;
 
@@ -12,6 +14,7 @@ public sealed class ModelDecimationService
 
     private readonly ILogger<ModelDecimationService> _logger;
     private readonly LightlessConfigService _configService;
+    private readonly FileCacheManager _fileCacheManager;
     private readonly PlayerPerformanceConfigService _performanceConfigService;
     private readonly XivDataStorageService _xivDataStorageService;
     private readonly SemaphoreSlim _decimationSemaphore = new(MaxConcurrentJobs);
@@ -23,11 +26,13 @@ public sealed class ModelDecimationService
     public ModelDecimationService(
         ILogger<ModelDecimationService> logger,
         LightlessConfigService configService,
+        FileCacheManager fileCacheManager,
         PlayerPerformanceConfigService performanceConfigService,
         XivDataStorageService xivDataStorageService)
     {
         _logger = logger;
         _configService = configService;
+        _fileCacheManager = fileCacheManager;
         _performanceConfigService = performanceConfigService;
         _xivDataStorageService = xivDataStorageService;
     }
@@ -145,7 +150,7 @@ public sealed class ModelDecimationService
         var destination = Path.Combine(GetDecimatedDirectory(), $"{hash}.mdl");
         if (File.Exists(destination))
         {
-            _decimatedPaths[hash] = destination;
+            RegisterDecimatedModel(hash, sourcePath, destination);
             return Task.CompletedTask;
         }
 
@@ -156,11 +161,92 @@ public sealed class ModelDecimationService
             return Task.CompletedTask;
         }
 
-        _decimatedPaths[hash] = destination;
+        RegisterDecimatedModel(hash, sourcePath, destination);
         _logger.LogInformation("Decimated model {Hash} -> {Path}", hash, destination);
         return Task.CompletedTask;
     }
 
+    private void RegisterDecimatedModel(string hash, string sourcePath, string destination)
+    {
+        _decimatedPaths[hash] = destination;
+
+        var performanceConfig = _performanceConfigService.Current;
+        if (performanceConfig.KeepOriginalModelFiles)
+        {
+            return;
+        }
+
+        if (string.Equals(sourcePath, destination, StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        if (!TryReplaceCacheEntryWithDecimated(hash, sourcePath, destination))
+        {
+            return;
+        }
+
+        TryDelete(sourcePath);
+    }
+
+    private bool TryReplaceCacheEntryWithDecimated(string hash, string sourcePath, string destination)
+    {
+        try
+        {
+            var cacheEntry = _fileCacheManager.GetFileCacheByHash(hash);
+            if (cacheEntry is null || !cacheEntry.IsCacheEntry)
+            {
+                return File.Exists(sourcePath) ? false : true;
+            }
+
+            var cacheFolder = _configService.Current.CacheFolder;
+            if (string.IsNullOrEmpty(cacheFolder))
+            {
+                return false;
+            }
+
+            if (!destination.StartsWith(cacheFolder, StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            var info = new FileInfo(destination);
+            if (!info.Exists)
+            {
+                return false;
+            }
+
+            var relative = Path.GetRelativePath(cacheFolder, destination)
+                .Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+            var sanitizedRelative = relative.TrimStart(Path.DirectorySeparatorChar);
+            var prefixed = Path.Combine(FileCacheManager.CachePrefix, sanitizedRelative);
+
+            var replacement = new FileCacheEntity(
+                hash,
+                prefixed,
+                info.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture),
+                info.Length,
+                cacheEntry.CompressedSize);
+            replacement.SetResolvedFilePath(destination);
+
+            if (!string.Equals(cacheEntry.PrefixedFilePath, prefixed, StringComparison.OrdinalIgnoreCase))
+            {
+                _fileCacheManager.RemoveHashedFile(cacheEntry.Hash, cacheEntry.PrefixedFilePath, removeDerivedFiles: false);
+            }
+
+            _fileCacheManager.UpdateHashedFile(replacement, computeProperties: false);
+            _fileCacheManager.WriteOutFullCsv();
+
+            _logger.LogTrace("Replaced cache entry for model {Hash} to decimated path {Path}", hash, destination);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogTrace(ex, "Failed to replace cache entry for model {Hash}", hash);
+            return false;
+        }
+    }
+
     private bool IsDecimationEnabled()
         => _performanceConfigService.Current.EnableModelDecimation;
 
@@ -272,4 +358,24 @@ public sealed class ModelDecimationService
 
         return directory;
     }
+
+    private static void TryDelete(string? path)
+    {
+        if (string.IsNullOrEmpty(path))
+        {
+            return;
+        }
+
+        try
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+        catch
+        {
+            // ignored
+        }
+    }
 }