using System.Net; using System.Runtime.CompilerServices; using System.Security.Cryptography; using System.Threading.Channels; using Chronos.Core.Metadata; using Chronos.Core.Model; using Chronos.Data.Sync; using Chronos.Protocol; using Chronos.Protocol.Client; namespace Chronos.Data.Tests.Sync; /// An in-memory Chronos Server for the sync engine: sequences with versions, originals, proxies, thumbnails and events. internal sealed class FakeSyncRemote : ISyncRemote { private readonly Lock _gate = new(); private readonly Channel _events = Channel.CreateUnbounded(); private readonly Dictionary _sessions = []; public string Server => "https://nas.test:8443"; public Dictionary Sequences { get; } = []; /// Manifest requests so far (comparisons skip them while frame counters stand still). public int ManifestCalls { get; private set; } /// Listings still to fail with a network error. public int FailingListings { get; set; } /// The next original download of this frame returns damaged bytes. public Guid? CorruptOnce { get; set; } /// Sequences the listing skips (a page boundary moved while it was read); they are still there. public HashSet Unlisted { get; } = []; /// Sequences whose manifest the server refuses (403), as for an account that lost a right. public HashSet Refused { get; } = []; /// Proxy and thumbnail downloads fail with a server error. public bool FailAssets { get; set; } /// /// Assets (frame id, kind) the sequence's flags offer that the server has not drawn yet: frames added since its last /// thumbnail or proxy pass answer 404 until that pass ends, as the real endpoints do. /// public HashSet<(Guid Frame, string Kind)> Undrawn { get; } = []; /// Proxies clients sent, by frame id (for sequences the server cannot decode). public Dictionary SentProxies { get; } = []; /// Edits the server accepted, in order. public List Updates { get; } = []; public FakeSequence Add(string? title, IEnumerable originals, string? settingsJson = null, SequenceStatus status = SequenceStatus.ProxiesBuilt | SequenceStatus.ThumbsBuilt) { var sequence = new FakeSequence { Id = Guid.CreateVersion7(), Title = title, SettingsJson = settingsJson, Status = status }; foreach (var bytes in originals) sequence.AddFrame(bytes); lock (_gate) Sequences[sequence.Id] = sequence; return sequence; } /// Someone else edits the settings on the server. public void EditSettings(Guid id, string settingsJson) { lock (_gate) { var s = Sequences[id]; s.SettingsJson = settingsJson; s.SettingsVersion++; s.UpdatedAt = DateTimeOffset.UtcNow; } } public void Publish(ServerEvent e) => _events.Writer.TryWrite(e); public Task> ListSequencesAsync(CancellationToken cancellationToken) { lock (_gate) { if (FailingListings > 0) { FailingListings--; throw new HttpRequestException("connection refused"); } return Task.FromResult>([.. Sequences.Values.Where(s => !Unlisted.Contains(s.Id)).Select(s => s.Dto())]); } } /// The next request for this sequence times out (HttpClient reports a timeout as a cancellation). public Guid? TimeoutOnce { get; set; } public Task GetSequenceAsync(Guid id, CancellationToken cancellationToken) { lock (_gate) { if (TimeoutOnce == id) { TimeoutOnce = null; throw new TaskCanceledException("The request timed out."); } return Task.FromResult(Find(id).Dto()); } } public Task GetManifestAsync(Guid id, CancellationToken cancellationToken) { lock (_gate) { ManifestCalls++; if (Refused.Contains(id)) throw new ChronosApiException(HttpStatusCode.Forbidden, new ApiError("forbidden", "refused")); return Task.FromResult(Find(id).Manifest(SentProxies.ContainsKey)); } } public Task> ListFramesAsync(Guid sequenceId, CancellationToken cancellationToken) { lock (_gate) { var sequence = Find(sequenceId); return Task.FromResult>([.. sequence.Frames.Select(sequence.FrameDto)]); } } public Task UpdateSequenceAsync(Guid id, UpdateSequenceRequest request, CancellationToken cancellationToken) { lock (_gate) { var s = Find(id); if (request.ExpectedSettingsVersion is { } expected && expected != s.SettingsVersion) throw new ChronosApiException(HttpStatusCode.Conflict, new ApiError("settings_conflict", "changed")); if (request.ExpectedFramesVersion is { } frames && frames != s.FramesVersion) throw new ChronosApiException(HttpStatusCode.Conflict, new ApiError("frames_conflict", "changed")); Updates.Add(request); if (request.Title is not null) s.Title = request.Title.Length == 0 ? null : request.Title; if (request.Tags is not null) s.Tags = [.. request.Tags]; if (request.Rating is { } rating) s.Rating = rating; if (request.Notes is not null) s.Notes = request.Notes.Length == 0 ? null : request.Notes; if (request.SettingsJson is not null) s.SettingsJson = request.SettingsJson; s.SettingsVersion++; s.UpdatedAt = DateTimeOffset.UtcNow; return Task.FromResult(s.Dto()); } } /// Like the server: content it already holds anywhere is not stored again; a session key files the first original into a new sequence. public async Task UploadFileAsync(string path, Guid? sequenceId, string? sessionKey, string sha256, DateTime? capturedAt, CancellationToken cancellationToken) { var bytes = await File.ReadAllBytesAsync(path, cancellationToken); if (Convert.ToHexStringLower(SHA256.HashData(bytes)) != sha256) throw new ChronosApiException(HttpStatusCode.BadRequest, new ApiError("hash_mismatch", "hash")); lock (_gate) { // Originals it never hashed are not recognised by content. if (Sequences.Values.Where(s => !s.Unhashed).SelectMany(s => s.Frames).FirstOrDefault(f => f.Sha256 == sha256) is { } existing) return new CompleteUploadResponse(existing.Id, sequenceId ?? Guid.Empty, -1); FakeSequence target; if (sequenceId is { } id) target = Find(id); else if (!_sessions.TryGetValue(sessionKey!, out target!)) { target = new FakeSequence { Id = Guid.CreateVersion7() }; Sequences[target.Id] = target; _sessions[sessionKey!] = target; } var frame = target.AddFrame(bytes, Path.GetFileName(path), capturedAt); return new CompleteUploadResponse(frame.Id, target.Id, target.Frames.Count - 1); } } public async Task DownloadFrameAsync(Guid frameId, string kind, Stream destination, CancellationToken cancellationToken) { byte[] bytes; lock (_gate) { var (sequence, frame) = Sequences.Values.SelectMany(s => s.Frames.Select(f => (s, f))).FirstOrDefault(p => p.f.Id == frameId); if (frame is null) throw NotFound(); bytes = kind switch { "original" when CorruptOnce == frameId => [.. frame.Bytes.Select(b => (byte)~b)], "original" => frame.Bytes, "proxy" or "thumb" when FailAssets => throw new ChronosApiException(HttpStatusCode.InternalServerError, new ApiError("internal", "failed")), "proxy" or "thumb" when Undrawn.Contains((frameId, kind)) => throw NotFound(), // A proxy a client or render node sent is served as soon as it is filed, like the manifest says. "proxy" when SentProxies.TryGetValue(frameId, out var sent) => sent, "proxy" when (sequence.Status & SequenceStatus.ProxiesBuilt) != 0 => frame.Proxy, "thumb" when (sequence.Status & SequenceStatus.ThumbsBuilt) != 0 => frame.Proxy[..Math.Min(frame.Proxy.Length, 64)], _ => throw NotFound(), }; if (kind == "original" && CorruptOnce == frameId) CorruptOnce = null; } // Range: continue after what the destination already holds, like the real endpoint. var offset = destination.CanSeek ? (int)Math.Min(destination.Length, bytes.Length) : 0; if (destination.CanSeek) destination.Seek(0, SeekOrigin.End); await destination.WriteAsync(bytes.AsMemory(offset), cancellationToken); } /// Like the server: only a frame whose proxy it asks for takes one, and only a JPEG. public Task UploadProxyAsync(Guid frameId, byte[] jpeg, CancellationToken cancellationToken) { lock (_gate) { if (!Sequences.Values.Any(s => s.Undecodable && s.Frames.Any(f => f.Id == frameId))) throw NotFound(); if (jpeg is not [0xFF, 0xD8, ..]) throw new ChronosApiException(HttpStatusCode.UnprocessableEntity, new ApiError("invalid_proxy", "not a JPEG")); SentProxies[frameId] = jpeg; } return Task.CompletedTask; } public async Task DownloadRenderAsync(Guid renderId, Stream destination, CancellationToken cancellationToken) { FakeRender render; lock (_gate) render = Sequences.Values.SelectMany(s => s.Renders).FirstOrDefault(r => r.Id == renderId) ?? throw NotFound(); var offset = destination.CanSeek ? (int)Math.Min(destination.Length, render.Bytes.Length) : 0; if (destination.CanSeek) destination.Seek(0, SeekOrigin.End); await destination.WriteAsync(render.Bytes.AsMemory(offset), cancellationToken); return render.FileName; } /// Like the server: the SHA-256 is checked and a render keeps its id; one it already has is not sent again. public async Task UploadRenderAsync(Guid sequenceId, string path, RenderUploadRequest request, CancellationToken cancellationToken) { var bytes = await File.ReadAllBytesAsync(path, cancellationToken); if (Convert.ToHexStringLower(SHA256.HashData(bytes)) != request.Sha256 || bytes.Length != request.Size) throw new ChronosApiException(HttpStatusCode.UnprocessableEntity, new ApiError("hash_mismatch", "hash")); lock (_gate) { var sequence = Find(sequenceId); if (sequence.Renders.Any(r => r.Id == request.RenderId)) return null; var render = new FakeRender(request.RenderId, request.FileName, request.PresetName, bytes); sequence.Renders.Add(render); return render.Dto(); } } public async IAsyncEnumerable EventsAsync([EnumeratorCancellation] CancellationToken cancellationToken) { while (await _events.Reader.WaitToReadAsync(cancellationToken)) { while (_events.Reader.TryRead(out var e)) yield return e; } } public void Dispose() { } private FakeSequence Find(Guid id) => Sequences.TryGetValue(id, out var s) ? s : throw NotFound(); private static ChronosApiException NotFound() => new(HttpStatusCode.NotFound, new ApiError("not_found", "sequence")); } internal sealed class FakeSequence { public required Guid Id { get; init; } public string? Title { get; set; } public List Tags { get; set; } = []; public int Rating { get; set; } public string? Notes { get; set; } public string? SettingsJson { get; set; } public int SettingsVersion { get; set; } = 1; public int FramesVersion { get; set; } public SequenceStatus Status { get; set; } /// The server cannot decode these originals (HEIF): its manifest asks for proxies of them. public bool Undecodable { get; set; } /// The server adopted these originals and never verified them: it lists no SHA-256 for them. public bool Unhashed { get; set; } public DateTimeOffset UpdatedAt { get; set; } = DateTimeOffset.UtcNow; public DateTime? FirstCapture { get; set; } public string? CameraModel { get; set; } = "Canon EOS R5"; public List Frames { get; } = []; public List Renders { get; } = []; /// Like the server, the capture time comes from the photo's Exif data when none is given. public FakeFrame AddFrame(byte[] bytes, string? name = null, DateTime? capturedAt = null) => InsertFrame(Frames.Count, bytes, name, capturedAt); /// A photo filed at (captured before the frames after it): those move up by one. public FakeFrame InsertFrame(int index, byte[] bytes, string? name = null, DateTime? capturedAt = null) { name ??= $"IMG_{Frames.Count + 1:0000}.JPG"; using var stream = new MemoryStream(bytes); var frame = new FakeFrame(Guid.CreateVersion7(), name, bytes, capturedAt ?? MetadataReader.Read(stream, name).CapturedAt); Frames.Insert(index, frame); FramesVersion++; UpdatedAt = DateTimeOffset.UtcNow; return frame; } public SequenceDto Dto() => new(Id, Title, Title ?? "Untitled", "2026/" + Id.ToString("N"), "Canon", CameraModel, null, FirstCapture, null, Frames.Count, 10, Frames.Sum(f => (long)f.Bytes.Length), (long)Status, Renders.Count, null, Tags, Rating, Notes, SettingsVersion, FramesVersion, 0, null, UpdatedAt); public SequenceManifest Manifest(Func proxySent) => new(Id, FramesVersion, SettingsVersion, SettingsJson, Tags, [.. Frames.Select((f, i) => new ManifestFrame(f.Id, i, f.FileName, f.Bytes.Length, Unhashed ? string.Empty : f.Sha256, (Status & SequenceStatus.ProxiesBuilt) != 0 || proxySent(f.Id), (Status & SequenceStatus.ThumbsBuilt) != 0, WantsProxy: Undecodable && !proxySent(f.Id)))], [.. Renders.Select(r => r.Dto())], Undecodable ? new ProxySpec(1280, 90) : null); public FrameDto FrameDto(FakeFrame frame) => frame.Dto(Id, Frames.IndexOf(frame), Unhashed); } internal sealed record FakeRender(Guid Id, string FileName, string PresetName, byte[] Bytes) { public RenderDto Dto() => new(Id, PresetName, "hevc", 3840, 2160, 30, 12, Bytes.Length, new DateTimeOffset(2026, 9, 20, 21, 0, 0, TimeSpan.Zero), "Studio NAS"); } internal sealed record FakeFrame(Guid Id, string FileName, byte[] Bytes, DateTime? CapturedAt) { public string Sha256 { get; } = Convert.ToHexStringLower(SHA256.HashData(Bytes)); /// The original stands in for its proxy: a real JPEG the decoders read. public byte[] Proxy => Bytes; public FrameDto Dto(Guid sequenceId, int index, bool unhashed = false) => new(Id, sequenceId, index, FileName, Bytes.Length, unhashed ? null : Sha256, CapturedAt, null, 1.0 / 250, 8, 100, 24, 1, 48, 32, "jpeg", 0); }