using System.Globalization; using Titano.Core.Analysis.Deep; using Titano.Core.Archiving; using Titano.Core.Localization; using Titano.Core.Model; using Titano.Data.Jobs; namespace Titano.Data.Processing.Jobs; /// /// and over the target sequences, one after the /// other. Progress counts sequences (light) or frames (deep). A sequence that cannot be analysed is logged and the /// others still run; the job then fails, and a retry analyses only the failed ones. An offline archive stops the job at /// once. Checkpoint: the next target and the failed ones (next[;i,j…]). A deep pass interrupted inside a /// sequence resumes from that sequence's analysis.partial. /// internal sealed class AnalyseJobHandler(TitanoDatabase db, SequenceAnalyser analyser, JobKind kind) : IJobHandler { public JobKind Kind => kind; public async Task RunAsync(JobContext context) { var deep = kind == JobKind.DeepAnalyse; var targets = context.Job.TargetIds; var (next, retry) = Parse(context.Checkpoint, targets.Count); // Deep progress is in frames across all targets, so the bar and the ETA cover the whole job. var units = new long[targets.Count]; for (var i = 0; i < targets.Count; i++) units[i] = deep ? (await db.Sequences.GetAsync(targets[i], context.Cancellation).ConfigureAwait(false))?.FrameCount ?? 0 : 1; var total = units.Sum(); var done = Enumerable.Range(0, next).Where(i => !retry.Contains(i)).Sum(i => units[i]); var failed = new List(); string? failure = null; int[] order = [.. retry, .. Enumerable.Range(next, targets.Count - next)]; for (var k = 0; k < order.Length; k++) { context.Cancellation.ThrowIfCancellationRequested(); var i = order[k]; var before = done; var chain = new ProgressChain(context.ReportAsync); var progress = deep ? chain.For(p => (before + p.Done, total, null)) : null; try { var outcome = await analyser.AnalyseAsync(targets[i], deep, progress, context.Cancellation).ConfigureAwait(false); await chain.FlushAsync().ConfigureAwait(false); if (outcome is null) context.Log(Loc.L("Archive.Log.SequenceMissing", targets[i])); else if (outcome.FramesChanged != FramesChange.None) await NotRecordedAsync(context, outcome).ConfigureAwait(false); else Report(context, outcome, deep); } catch (Exception ex) when (ex is not (OperationCanceledException or ArchiveOfflineException)) { await chain.FlushAsync().ConfigureAwait(false); Core.Diagnostics.Log.Warning("processing", $"Analysis of sequence {targets[i]} failed", ex); failure = Loc.L("Advisor.Log.Failed", await TitleAsync(targets[i], context.Cancellation).ConfigureAwait(false), ex.Message); context.Log(failure); failed.Add(i); } done += units[i]; next = int.Max(next, i + 1); // Failed targets of an earlier attempt not retried yet stay listed. await context.CheckpointAsync(Format(next, [.. failed, .. retry.Skip(k + 1)]), done, total).ConfigureAwait(false); } // One failure is the job's error as it was logged; several are counted (the log names each). if (failed.Count > 0) throw new InvalidOperationException(failed.Count == 1 ? failure : Loc.L("Errors.Analysis.Failed", failed.Count, targets.Count)); } /// /// A sequence whose frames changed while it was analysed: nothing was recorded from the frames the analysis read (the /// deep report it saved counts only for the frames it describes). When this index holds the frames as they are, and no /// light analysis is queued for it, one is queued; frames another process changed are analysed by that process, and /// indexed here by the next scan (). /// private async Task NotRecordedAsync(JobContext context, AnalysisOutcome outcome) { var sequence = outcome.Sequence; if (outcome.FramesChanged == FramesChange.NotIndexed) { context.Log(Loc.L("Advisor.Log.FramesChangedElsewhere", sequence.DisplayTitle)); return; } context.Log(Loc.L("Advisor.Log.FramesChanged", sequence.DisplayTitle)); await AnalysisFollowUp.QueueAsync(db, context, [sequence.Id], sequence.DisplayTitle).ConfigureAwait(false); } private async Task TitleAsync(Guid sequenceId, CancellationToken cancellationToken) => (await db.Sequences.GetAsync(sequenceId, cancellationToken).ConfigureAwait(false))?.DisplayTitle ?? sequenceId.ToString(); private static void Report(JobContext context, AnalysisOutcome outcome, bool deep) { var title = outcome.Sequence.DisplayTitle; context.Log(Loc.L(deep ? "Advisor.Log.DeepDone" : "Advisor.Log.LightDone", title, outcome.Frames, outcome.Warnings)); if (outcome.SettingsChanged) context.Log(Loc.L("Advisor.Log.AutoUpdated", title)); if (outcome.SettingsUnreadable) context.Log(Loc.L("Advisor.Log.ProjectUnreadable", title)); if (outcome.Presets.Count > 0) context.Log(Loc.L("Advisor.Log.Presets", string.Join(" · ", outcome.Presets.Select(p => p.DisplayName())))); } /// Next target and the failed targets to retry first; a missing or unreadable checkpoint starts over. internal static (int Next, IReadOnlyList Retry) Parse(string? checkpoint, int count) { var parts = checkpoint?.Split(';'); if (parts is not ([_] or [_, _]) || !int.TryParse(parts[0], NumberStyles.None, CultureInfo.InvariantCulture, out var next) || next > count) return (0, []); var retry = new List(); foreach (var item in parts.Length == 2 ? parts[1].Split(',') : []) { if (!int.TryParse(item, NumberStyles.None, CultureInfo.InvariantCulture, out var index) || index >= next) return (0, []); if (!retry.Contains(index)) retry.Add(index); } return (next, retry); } internal static string Format(int next, IReadOnlyCollection failed) => failed.Count == 0 ? next.ToString(CultureInfo.InvariantCulture) : string.Create(CultureInfo.InvariantCulture, $"{next};{string.Join(',', failed.Order())}"); }