using System.Globalization; using Chronos.App.Editor; using Chronos.Core.Analysis; using Chronos.Core.Analysis.Deep; using Chronos.Core.Diagnostics.Synthetic; using Chronos.Core.Imaging; using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Core.Render.Diagnostics; using Chronos.Data.Archiving.Jobs; namespace Chronos.App.Tests.Editor; /// A synthetic sunset with flicker and two exposure steps, as the editor tests open it. internal static class EditorFixture { private static readonly Lazy Shared = new(() => Sequence()); static EditorFixture() => Loc.SetCulture(CultureInfo.GetCultureInfo("en")); public static SyntheticSequence Sunset => Shared.Value; public static SyntheticSequence Sequence(int frames = 72) => SyntheticSequence.Create(new SyntheticSequenceOptions { Width = 96, Height = 64, FrameCount = frames, StartEv = 0, EndEv = -2, FlickerEv = 0.25, ExposureSteps = [new SyntheticExposureStep(24, -1), new SyntheticExposureStep(48, -1)], StartKelvin = 5200, EndKelvin = 3400, }); /// The sequence as returns it, with a deep analysis when asked. public static SequenceContent Content(SyntheticSequence sequence, ProjectSettings? project = null, bool deep = true) { var id = Guid.CreateVersion7(); var frames = sequence.Frames.Select(f => f with { SequenceId = id }).ToList(); var row = new Sequence { Id = id, ArchiveId = Guid.CreateVersion7(), Title = "Harbour sunset", Folder = "2026/2026-09-28 Synthetic", CameraMake = sequence.Options.CameraMake, CameraModel = sequence.Options.CameraModel, FirstCapture = frames[0].CapturedAt, LastCapture = frames[^1].CapturedAt, FrameCount = frames.Count, MedianInterval = sequence.Options.IntervalSeconds, }; var report = deep ? DeepAnalyzer.AnalyzeAsync(new Frames(sequence)).GetAwaiter().GetResult() : null; return new SequenceContent(row, frames, project ?? new ProjectSettings(), LightAnalyzer.Analyze(frames), report, sequence.Options.Width, sequence.Options.Height, null, [], []); } /// Synthetic frames as the deep analysis reads them. private sealed class Frames(SyntheticSequence sequence) : IFrameSource { public int Count => sequence.Count; public LightFrame Metadata(int index) => LightFrame.From(sequence.Metadata[index], index); public ValueTask LoadAsync(int index, int maxLongEdge, CancellationToken cancellationToken) => ValueTask.FromResult(sequence.Render(index)); } } /// /// An in-memory : synthetic pixels, a stored project with the same merge rule as the /// archive, recorded jobs. simulates someone else changing the stored project before a save. /// internal sealed class FakeSequenceSource(SyntheticSequence sequence, SequenceContent content) : ISequenceSource { private readonly SyntheticFrameSource _pixels = new(sequence); /// The frames the session read last (opened with, or loaded since). private IReadOnlyList _read = content.Frames; public ProjectSettings Stored { get; set; } = content.Project; public SequenceContent Content { get; set; } = content; public List Submitted { get; } = []; /// A server sequence: renders become one job per preset. public bool IsRemote { get; init; } public bool IsReadOnly { get; set; } public bool IsOutdated { get; private set; } /// Jobs cancelled and retried through the source. public List Cancelled { get; } = []; public List Retried { get; } = []; /// Jobs returns. public List Jobs { get; } = []; public int Saves { get; private set; } public int Decodes { get; private set; } /// Applied to the stored project before the next save reads it. public Func? ExternalEdit { get; set; } /// Thrown by the next save. public Exception? FailNextSave { get; set; } /// Thrown by every save while set (an archive that stays offline). public Exception? FailSaves { get; set; } /// Awaited by every decode (tests of cancellation). public Task DecodeGate { get; set; } = Task.CompletedTask; /// Thrown by the next load (the sequence read again after a job). public Exception? FailNextLoad { get; set; } /// Awaited by the next load once it has read the sequence (a read that is slow to complete). public Task? NextLoadGate { get; set; } /// Times the sequence was read (). public int Loads { get; private set; } public async Task LoadAsync(CancellationToken cancellationToken) { if (FailNextLoad is { } failure) { FailNextLoad = null; throw failure; } Loads++; var content = Content with { Project = Stored }; if (NextLoadGate is { } gate) { NextLoadGate = null; await gate; } _read = content.Frames; return content; } /// Whether holds the frames read last; a server sequence becomes outdated when not. public Task FramesCurrentAsync(CancellationToken cancellationToken) { var current = _read.Select(f => f.Id).SequenceEqual(Content.Frames.Select(f => f.Id)); if (!current && IsRemote) MarkOutdated(); return Task.FromResult(current); } public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { await DecodeGate.WaitAsync(cancellationToken); Decodes++; return await _pixels.GetFrameAsync(index, maxLongEdge, purpose, cancellationToken); } public Task SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken) { if (FailSaves is { } lasting) return Task.FromException(lasting); if (FailNextSave is { } failure) { FailNextSave = null; return Task.FromException(failure); } if (ExternalEdit is { } edit) { Stored = edit(Stored); ExternalEdit = null; } Stored = ProjectMerge.SameValues(Stored, basis) ? project : ProjectMerge.Merge(basis, project, Stored); Saves++; return Task.FromResult(Stored); } public Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken) { Submitted.Add(request); return Task.FromResult(Guid.CreateVersion7()); } public event Action? JobChanged; public event Action? ReadOnlyChanged; /// The server's frames changed under the proxies (as a server sequence finds out). public void MarkOutdated() { IsOutdated = IsReadOnly = true; ReadOnlyChanged?.Invoke(); } public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken) { Cancelled.Add(jobId); return Task.CompletedTask; } public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken) { Retried.Add(jobId); return Task.CompletedTask; } public Task> ListJobsAsync(CancellationToken cancellationToken) => Task.FromResult>([.. Jobs]); /// A job of the sequence changed (as the engine or the server reports it). public void Report(Job job) => JobChanged?.Invoke(job); public ValueTask DisposeAsync() => ValueTask.CompletedTask; }