feat: async session cleanup and fix live room scroll

src/LiveRecorder.Domain/Entities/CleanupOperation.cs

@@ -0,0 +1,165 @@
+using System.Text.Json;
+using LiveRecorder.Domain.Enums;
+
+namespace LiveRecorder.Domain.Entities;
+
+public class CleanupOperation
+{
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
+
+    private CleanupOperation()
+    {
+    }
+
+    public CleanupOperation(
+        CleanupOperationKind kind,
+        bool deleteFiles,
+        string? filtersJson,
+        DateTimeOffset createdAt)
+    {
+        Id = Guid.NewGuid();
+        Kind = kind;
+        Status = CleanupOperationStatus.Queued;
+        DeleteFiles = deleteFiles;
+        FiltersJson = string.IsNullOrWhiteSpace(filtersJson) ? "{}" : filtersJson;
+        WarningsJson = "[]";
+        CreatedAt = createdAt;
+    }
+
+    public Guid Id { get; private set; }
+
+    public CleanupOperationKind Kind { get; private set; }
+
+    public CleanupOperationStatus Status { get; private set; }
+
+    public bool DeleteFiles { get; private set; }
+
+    public string FiltersJson { get; private set; } = "{}";
+
+    public DateTimeOffset CreatedAt { get; private set; }
+
+    public DateTimeOffset? StartedAt { get; private set; }
+
+    public DateTimeOffset? CompletedAt { get; private set; }
+
+    public int TotalSessionCount { get; private set; }
+
+    public int ProcessedSessionCount { get; private set; }
+
+    public int DeletedSessionCount { get; private set; }
+
+    public int DeletedTaskCount { get; private set; }
+
+    public int DeletedResultCount { get; private set; }
+
+    public int DeletedLogCount { get; private set; }
+
+    public int DeletedFileCount { get; private set; }
+
+    public int DeletedDanmakuFileCount { get; private set; }
+
+    public string WarningsJson { get; private set; } = "[]";
+
+    public string? ErrorMessage { get; private set; }
+
+    public void MarkRunning(DateTimeOffset startedAt)
+    {
+        Status = CleanupOperationStatus.Running;
+        StartedAt = startedAt;
+        CompletedAt = null;
+        ErrorMessage = null;
+    }
+
+    public void SetTotalSessionCount(int totalSessionCount)
+    {
+        TotalSessionCount = Math.Max(0, totalSessionCount);
+        if (ProcessedSessionCount > TotalSessionCount)
+        {
+            ProcessedSessionCount = TotalSessionCount;
+        }
+    }
+
+    public void MarkCompleted(DateTimeOffset completedAt)
+    {
+        Status = CleanupOperationStatus.Completed;
+        CompletedAt = completedAt;
+        ErrorMessage = null;
+    }
+
+    public void MarkFailed(string errorMessage, DateTimeOffset completedAt)
+    {
+        Status = CleanupOperationStatus.Failed;
+        CompletedAt = completedAt;
+        ErrorMessage = string.IsNullOrWhiteSpace(errorMessage)
+            ? "Cleanup operation failed."
+            : errorMessage.Trim();
+    }
+
+    public void Requeue(string warning)
+    {
+        Status = CleanupOperationStatus.Queued;
+        StartedAt = null;
+        CompletedAt = null;
+        ErrorMessage = null;
+        AppendWarnings([warning]);
+    }
+
+    public void ApplyBatchProgress(
+        int processedSessionCount,
+        int deletedSessionCount,
+        int deletedTaskCount,
+        int deletedResultCount,
+        int deletedLogCount,
+        int deletedFileCount,
+        int deletedDanmakuFileCount,
+        IReadOnlyCollection<string>? warnings = null)
+    {
+        ProcessedSessionCount += Math.Max(0, processedSessionCount);
+        DeletedSessionCount += Math.Max(0, deletedSessionCount);
+        DeletedTaskCount += Math.Max(0, deletedTaskCount);
+        DeletedResultCount += Math.Max(0, deletedResultCount);
+        DeletedLogCount += Math.Max(0, deletedLogCount);
+        DeletedFileCount += Math.Max(0, deletedFileCount);
+        DeletedDanmakuFileCount += Math.Max(0, deletedDanmakuFileCount);
+
+        if (ProcessedSessionCount > TotalSessionCount)
+        {
+            ProcessedSessionCount = TotalSessionCount;
+        }
+
+        if (warnings is { Count: > 0 })
+        {
+            AppendWarnings(warnings);
+        }
+    }
+
+    public IReadOnlyList<string> GetWarnings()
+    {
+        if (string.IsNullOrWhiteSpace(WarningsJson))
+        {
+            return [];
+        }
+
+        try
+        {
+            return JsonSerializer.Deserialize<List<string>>(WarningsJson, JsonOptions) ?? [];
+        }
+        catch
+        {
+            return [];
+        }
+    }
+
+    private void AppendWarnings(IReadOnlyCollection<string> warnings)
+    {
+        if (warnings.Count == 0)
+        {
+            return;
+        }
+
+        var merged = GetWarnings().Concat(warnings.Where(static item => !string.IsNullOrWhiteSpace(item)))
+            .Select(static item => item.Trim())
+            .ToList();
+        WarningsJson = JsonSerializer.Serialize(merged, JsonOptions);
+    }
+}