feat(ui): SRS scan-progress modals, Main File option, Compare-tab Cluster matching, reconstructor warnings

NeWbY100 · claude · NeWbY100 · commit 8c1e4a4fd881 · 2026-05-12T19:13:37.000+09:00
SRS Reconstructor:
- Modal stays open through "Rebuilding" and "Verifying CRC" instead of
  closing the moment the find-tracks phase ends. Heading transitions to
  "Rebuilding Sample" while CollectMediaFrameData walks the media file,
  then "Verifying CRC" while the output is hashed; closes on "Complete".
- Live scan progress (percent, MB scanned, throughput, ETA) is rendered
  during the frame-data collection and the attachment-extraction passes
  via the library's new ScanProgress event on SRSRebuilder.

SRS Creator:
- New "Main file" input row (Browse + Clear). When set, the SRS
  creation pipeline runs the library's main-file verification step and
  the resulting SRS carries each track's MatchOffset — equivalent to
  pyrescene's -c flag, used by scene-tool when packaging samples.
- Progress modal now appears during the long Profiling Sample step
  (previously a silent 6+ seconds on large samples). Transitions to
  "Verifying Against Main File" while the verifier scans, then
  "Writing SRS" before closing.
- ISrsCreationService / SRSCreationService forward the writer's
  ScanProgress event into the viewmodel.

Compare tab:
- FindMatchingNodeRecursive special-cases SRSContainerChunks: the
  "Container Structure" parent and its many chunk children all share
  NodeType=SRSContainerChunks with FileName=null, so the previous
  generic match returned whichever SRSContainerChunks node it saw first
  (usually the parent, whose Data is a List&lt;SRSContainerChunk&gt; rather
  than a single chunk) — collapsing to an empty properties panel.
  Match parent-to-parent and chunk-to-chunk by Label instead.

RAR Reconstructor:
- After loading an SRR, warn via MessageBox when it contains no RAR
  reconstruction info (zero RAR file entries, zero archived files, and
  no detected compression method). The import still completes — empty
  imported state clears any stale data from a previous session — but
  the user is told to configure options manually instead of being left
  confused.
- Subscribe to BruteForceService.TimestampPreservationFailed and
  accumulate failures during a run. When the operation completes, pop
  a single summary MessageBox listing up to 10 affected paths and the
  error message per failure, explaining that the produced RAR's File
  Time (DOS) may not match the original. Per-file warnings still go
  through the system log in real time.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/ReScene.NET/Services/BruteForceService.cs b/ReScene.NET/Services/BruteForceService.cs
@@ -12,6 +12,7 @@ public class BruteForceService : IBruteForceService
     public event EventHandler<LogEventArgs>? LogMessage;
     public event EventHandler<FileCopyProgressEventArgs>? FileCopyProgress;
     public event EventHandler<CRCValidationProgressEventArgs>? CRCValidationProgress;
+    public event EventHandler<TimestampPreservationFailedEventArgs>? TimestampPreservationFailed;
 
     private Manager? _manager;
 
@@ -25,6 +26,7 @@ public async Task<bool> RunAsync(BruteForceOptions options)
         _manager.BruteForceStatusChanged += (s, e) => StatusChanged?.Invoke(s, e);
         _manager.FileCopyProgress += (s, e) => FileCopyProgress?.Invoke(s, e);
         _manager.CRCValidationProgress += (s, e) => CRCValidationProgress?.Invoke(s, e);
+        _manager.TimestampPreservationFailed += (s, e) => TimestampPreservationFailed?.Invoke(s, e);
 
         return await _manager.BruteForceRARVersionAsync(options);
     }
diff --git a/ReScene.NET/Services/IBruteForceService.cs b/ReScene.NET/Services/IBruteForceService.cs
@@ -11,4 +11,5 @@ public interface IBruteForceService
     public event EventHandler<LogEventArgs>? LogMessage;
     public event EventHandler<FileCopyProgressEventArgs>? FileCopyProgress;
     public event EventHandler<CRCValidationProgressEventArgs>? CRCValidationProgress;
+    public event EventHandler<TimestampPreservationFailedEventArgs>? TimestampPreservationFailed;
 }
diff --git a/ReScene.NET/Services/ISrsCreationService.cs b/ReScene.NET/Services/ISrsCreationService.cs
@@ -12,6 +12,11 @@ public interface ISrsCreationService
     /// </summary>
     public event EventHandler<SRSCreationProgressEventArgs>? Progress;
 
+    /// <summary>
+    /// Raised to report byte-level scan progress during sample profiling.
+    /// </summary>
+    public event EventHandler<SRSScanProgressEventArgs>? ScanProgress;
+
     /// <summary>
     /// Creates an SRS file from a sample media file.
     /// </summary>
diff --git a/ReScene.NET/Services/SRSCreationService.cs b/ReScene.NET/Services/SRSCreationService.cs
@@ -16,6 +16,13 @@ public event EventHandler<SRSCreationProgressEventArgs>? Progress
         remove => _writer.Progress -= value;
     }
 
+    /// <inheritdoc />
+    public event EventHandler<SRSScanProgressEventArgs>? ScanProgress
+    {
+        add => _writer.ScanProgress += value;
+        remove => _writer.ScanProgress -= value;
+    }
+
     /// <inheritdoc />
     public Task<SRSCreationResult> CreateAsync(
         string outputPath,
diff --git a/ReScene.NET/ViewModels/FileCompareViewModel.cs b/ReScene.NET/ViewModels/FileCompareViewModel.cs
@@ -1347,6 +1347,27 @@ private void SyncTreeSelection(ObservableCollection<TreeNodeViewModel> targetRoo
                     }
                 }
             }
+            else if (nodeData.NodeType == CompareNodeType.SRSContainerChunks
+                  && sourceData.NodeType == CompareNodeType.SRSContainerChunks)
+            {
+                // SRSContainerChunks NodeType is shared by both the "Container
+                // Structure" parent (Data = List<SRSContainerChunk>) and every
+                // chunk child (Data = SRSContainerChunk). Match parent-to-parent
+                // and chunk-to-chunk by Label so a clicked Cluster lights up the
+                // corresponding Cluster on the other side rather than the first
+                // SRSContainerChunks node encountered.
+                if (nodeData.Data is List<SRSContainerChunk> && sourceData.Data is List<SRSContainerChunk>)
+                {
+                    return node;
+                }
+
+                if (nodeData.Data is SRSContainerChunk nodeChunk
+                    && sourceData.Data is SRSContainerChunk sourceChunk
+                    && nodeChunk.Label == sourceChunk.Label)
+                {
+                    return node;
+                }
+            }
             else if (nodeData.NodeType == sourceData.NodeType && nodeData.FileName == sourceData.FileName)
             {
                 return node;
diff --git a/ReScene.NET/ViewModels/ReconstructorViewModel.cs b/ReScene.NET/ViewModels/ReconstructorViewModel.cs
@@ -58,6 +58,12 @@ public partial class ReconstructorViewModel : ViewModelBase
     private CustomPackerType _importedCustomPackerType = CustomPackerType.None;
     private string? _importedSRRFilePath;
 
+    // Timestamp-preservation failures accumulated during the current run.
+    // Surfaced as a single MessageBox when the operation completes so the
+    // user is aware that the resulting RAR's File Time (DOS) may not match
+    // the original for those files.
+    private readonly List<TimestampPreservationFailedEventArgs> _timestampFailures = [];
+
     public ReconstructorViewModel(IBruteForceService bruteForceService, IFileDialogService fileDialog)
     {
         _bruteForceService = bruteForceService;
@@ -68,6 +74,7 @@ public ReconstructorViewModel(IBruteForceService bruteForceService, IFileDialogS
         _bruteForceService.LogMessage += OnLogMessage;
         _bruteForceService.FileCopyProgress += OnFileCopyProgress;
         _bruteForceService.CRCValidationProgress += OnCRCValidationProgress;
+        _bruteForceService.TimestampPreservationFailed += OnTimestampPreservationFailed;
 
         _elapsedTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(1) };
         _elapsedTimer.Tick += (_, _) => OnElapsedTimerTick();
@@ -369,6 +376,27 @@ private async Task ImportSRRAsync()
             var srr = SRRFile.Load(path);
             Log(LogTarget.System, "SRR loaded successfully");
 
+            // Detect SRRs that carry no RAR reconstruction information
+            // (no RAR volume entries, no archived-file metadata, no detected
+            // compression method). These can't drive automatic option setup,
+            // so warn the user that they'll need to configure things manually.
+            bool hasRarReconstructionInfo = srr.RARFiles.Count > 0
+                || srr.ArchivedFiles.Count > 0
+                || srr.CompressionMethod.HasValue;
+
+            if (!hasRarReconstructionInfo)
+            {
+                Log(LogTarget.System,
+                    "WARNING: SRR contains no RAR reconstruction information.");
+                MessageBox.Show(
+                    "This SRR file does not contain RAR reconstruction information " +
+                    "(no RAR volume entries, archived files, or compression metadata).\n\n" +
+                    "You will need to configure the RAR options manually before reconstructing.",
+                    "No RAR Reconstruction Info",
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Information);
+            }
+
             // Custom packer detection
             if (srr.HasCustomPackerHeaders)
             {
@@ -1124,6 +1152,7 @@ private async Task StartAsync()
         SystemLog = string.Empty;
         Phase1Log = string.Empty;
         Phase2Log = string.Empty;
+        _timestampFailures.Clear();
 
         // Reset progress window state
         TestCountText = string.Empty;
@@ -1894,10 +1923,57 @@ private void OnStatusChanged(object? _, BruteForceStatusChangedEventArgs e)
                     OperationCompletionStatus.Cancelled => "Cancelled.",
                     _ => "Completed."
                 };
+
+                ShowTimestampFailureWarningIfAny();
             }
         });
     }
 
+    private void OnTimestampPreservationFailed(object? _, TimestampPreservationFailedEventArgs e)
+    {
+        // The library already logs a Warning via its logger (routed through
+        // OnLogMessage). Track the failure here so we can show a single
+        // summary MessageBox when the run finishes.
+        _timestampFailures.Add(e);
+    }
+
+    private void ShowTimestampFailureWarningIfAny()
+    {
+        if (_timestampFailures.Count == 0)
+        {
+            return;
+        }
+
+        const int MaxFilesToList = 10;
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine("Could not copy the source file's modification time onto the working copy " +
+                      "for the following file(s):");
+        sb.AppendLine();
+
+        int shown = Math.Min(_timestampFailures.Count, MaxFilesToList);
+        for (int i = 0; i < shown; i++)
+        {
+            TimestampPreservationFailedEventArgs f = _timestampFailures[i];
+            sb.AppendLine($"  • {f.DestinationPath}");
+            sb.AppendLine($"      ({f.ErrorMessage})");
+        }
+
+        if (_timestampFailures.Count > MaxFilesToList)
+        {
+            sb.AppendLine($"  … and {_timestampFailures.Count - MaxFilesToList} more.");
+        }
+
+        sb.AppendLine();
+        sb.AppendLine("WinRAR will pack these files with the copy time instead of the original " +
+                      "modification time, so the resulting RAR's File Time (DOS) may differ " +
+                      "from the original release.");
+
+        MessageBox.Show(sb.ToString(),
+            "Timestamp Preservation Failed",
+            MessageBoxButton.OK,
+            MessageBoxImage.Warning);
+    }
+
     private void OnLogMessage(object? _, LogEventArgs e) => Application.Current.Dispatcher.Invoke(() => AppendLog(e.Target, e.Message));
 
     private void Log(LogTarget target, string message) => AppendLog(target, message);
diff --git a/ReScene.NET/ViewModels/SRSCreatorViewModel.cs b/ReScene.NET/ViewModels/SRSCreatorViewModel.cs
@@ -1,4 +1,5 @@
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Windows;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
@@ -26,6 +27,7 @@ public SRSCreatorViewModel(ISrsCreationService srsService, IFileDialogService fi
         _settingsService = settingsService;
 
         _sRSService.Progress += OnProgress;
+        _sRSService.ScanProgress += OnScanProgress;
 
         AppSettings settings = _settingsService.Load();
 
@@ -108,11 +110,18 @@ public SRSCreatorViewModel(ISrsCreationService srsService, IFileDialogService fi
     [ObservableProperty]
     private bool _iSOProcessing;
 
+    private Stopwatch? _scanStopwatch;
+    private bool _scanModalActive;
+
     // Output
     [ObservableProperty]
     [NotifyCanExecuteChangedFor(nameof(CreateSRSCommand))]
     private string _outputPath = string.Empty;
 
+    // Optional main file for match-offset verification (mirrors pyrescene -c)
+    [ObservableProperty]
+    private string _mainFilePath = string.Empty;
+
     // Options
     [ObservableProperty]
     private string _appName = string.Empty;
@@ -178,6 +187,21 @@ private async Task BrowseInputAsync()
         }
     }
 
+    [RelayCommand]
+    private async Task BrowseMainFileAsync()
+    {
+        string? path = await _fileDialog.OpenFileAsync("Select Main File (Full Movie)",
+            FileDialogFilters.MediaFiles);
+
+        if (path is not null)
+        {
+            MainFilePath = path;
+        }
+    }
+
+    [RelayCommand]
+    private void ClearMainFile() => MainFilePath = string.Empty;
+
     [RelayCommand]
     private async Task BrowseOutputAsync()
     {
@@ -219,7 +243,8 @@ private async Task CreateSRSAsync()
         {
             var options = new SRSCreationOptions
             {
-                AppName = string.IsNullOrWhiteSpace(AppName) ? FormatUtilities.GetDefaultAppName() : AppName
+                AppName = string.IsNullOrWhiteSpace(AppName) ? FormatUtilities.GetDefaultAppName() : AppName,
+                MainFilePath = string.IsNullOrWhiteSpace(MainFilePath) ? null : MainFilePath
             };
 
             Log("Starting SRS creation...");
@@ -274,9 +299,30 @@ await ISOMediaExtractor.ExtractFileAsync(
             Log($"Input:  {samplePath}");
             Log($"Output: {OutputPath}");
 
+            // Show progress modal during profiling (can take many seconds on large samples)
+            ISOProgressHeading = "Profiling Sample";
+            ISOCurrentFileText = Path.GetFileName(samplePath);
+            ISOFileCountText = "Reading sample structure and computing CRC...";
+            ISOOverallPercent = 0;
+            ISOCurrentPercent = 0;
+            ISOCurrentSizeText = string.Empty;
+            ISOProcessedText = string.Empty;
+            ISORemainingText = string.Empty;
+            ISOSpeedText = string.Empty;
+            ISOEtaText = string.Empty;
+            _scanStopwatch = Stopwatch.StartNew();
+            _scanModalActive = true;
+            ISOProcessing = true;
+
+            // Yield to let the dispatcher open the modal before heavy work starts
+            await Task.Yield();
+
             SRSCreationResult result = await _sRSService.CreateAsync(
                 OutputPath, samplePath, options, _cts.Token);
 
+            _scanModalActive = false;
+            ISOProcessing = false;
+
             if (result.Success)
             {
                 ProgressPercent = 100;
@@ -311,6 +357,7 @@ await ISOMediaExtractor.ExtractFileAsync(
         }
         finally
         {
+            _scanModalActive = false;
             ISOProcessing = false;
             IsCreating = false;
             _cts?.Dispose();
@@ -359,9 +406,72 @@ private void OnProgress(object? _, SRSCreationProgressEventArgs e)
         {
             ProgressMessage = e.Message;
             Log(e.Message);
+
+            if (!_scanModalActive)
+            {
+                return;
+            }
+
+            // Transition the modal as we move from profiling -> verifying -> writing -> complete
+            if (e.Message.StartsWith("Verifying sample against main file", StringComparison.OrdinalIgnoreCase))
+            {
+                ISOProgressHeading = "Verifying Against Main File";
+                ISOCurrentFileText = "Searching for track signatures in main file...";
+                ISOOverallPercent = 0;
+                ISOCurrentPercent = 0;
+                _scanStopwatch?.Restart();
+            }
+            else if (e.Message.StartsWith("Writing SRS", StringComparison.OrdinalIgnoreCase))
+            {
+                ISOProgressHeading = "Writing SRS";
+                ISOCurrentFileText = "Writing SRS file...";
+                ISOOverallPercent = 100;
+                ISOCurrentPercent = 100;
+            }
+        });
+    }
+
+    private void OnScanProgress(object? _, SRSScanProgressEventArgs e)
+    {
+        Application.Current.Dispatcher.BeginInvoke(() =>
+        {
+            if (!_scanModalActive)
+            {
+                return;
+            }
+
+            ISOOverallPercent = e.Percent;
+            ISOCurrentPercent = e.Percent;
+            ISOCurrentFileText = e.Phase;
+            UpdateScanStats(e.BytesScanned, e.BytesTotal);
         });
     }
 
+    private void UpdateScanStats(long processed, long total)
+    {
+        if (total <= 0 || _scanStopwatch is null)
+        {
+            return;
+        }
+
+        double elapsed = _scanStopwatch.Elapsed.TotalSeconds;
+        ISOProcessedText = $"{FormatUtilities.FormatSize(processed)} / {FormatUtilities.FormatSize(total)}";
+
+        long remaining = total - processed;
+        ISORemainingText = FormatUtilities.FormatSize(remaining);
+
+        if (elapsed > 0.5 && processed > 0)
+        {
+            double bytesPerSec = processed / elapsed;
+            ISOSpeedText = $"{FormatUtilities.FormatSize((long)bytesPerSec)}/s";
+
+            double secondsRemaining = remaining / bytesPerSec;
+            ISOEtaText = secondsRemaining < 60
+                ? $"{secondsRemaining:F0}s"
+                : $"{(int)(secondsRemaining / 60)}m {(int)(secondsRemaining % 60)}s";
+        }
+    }
+
     private void Log(string message) => AppendLogEntry(LogEntries, message);
 
     #region ISO Support
diff --git a/ReScene.NET/ViewModels/SRSReconstructorViewModel.cs b/ReScene.NET/ViewModels/SRSReconstructorViewModel.cs
diff --git a/ReScene.NET/Views/SRSCreatorView.xaml b/ReScene.NET/Views/SRSCreatorView.xaml

Original file line number	Diff line number	Diff line change
`@@ -11,4 +11,5 @@ public interface IBruteForceService`
`11`	`11`	`public event EventHandler<LogEventArgs>? LogMessage;`
`12`	`12`	`public event EventHandler<FileCopyProgressEventArgs>? FileCopyProgress;`
`13`	`13`	`public event EventHandler<CRCValidationProgressEventArgs>? CRCValidationProgress;`
	`14`	`+ public event EventHandler<TimestampPreservationFailedEventArgs>? TimestampPreservationFailed;`
`14`	`15`	`}`