using System.IO;
using System.Text.Json;
using Chronos.Core.Advice;
using Chronos.Core.Analysis;
using Chronos.Core.Analysis.Deep;
using Chronos.Core.Archiving;
using Chronos.Core.Diagnostics;
using Chronos.Core.Export;
using Chronos.Core.Imaging;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Core.Render;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Data.Archiving.Jobs;
using Chronos.Data.Jobs;
using Chronos.Data.Processing;
using Chronos.Data.Projects;
using Chronos.Data.Workspaces;
using Chronos.Protocol;
namespace Chronos.App.Editor;
/// A source whose renders are made otherwise than from the project as the editor holds it (a workspace project: at its home).
public interface IProjectRenders
{
/// The jobs that render of (the editor's settings, positions on the source's frames).
IReadOnlyList RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight);
}
///
/// A workspace project open in the editor (owner review 2, R8: editing happens in the workspace, never inside the
/// library): the frames and pixels of the media the workspace holds (media/media.json, the proxies), the project
/// from its working state (project.chronos, positions placed on those frames), saved there atomically under the
/// project's lease and merged against the basis like (a pull or a copy job writes it
/// too). Jobs run on this PC's engine against the home's sequence (same id): an analysis reads the home's originals, a
/// render renders the home's originals with the project's portable settings and records the project and the version
/// (). The deep report is the home's while its frames are the media's, else the copy the
/// workspace took. A copy job that changed the media (Update media) makes saves made against the frames read before refused
/// () until the editor has read them again and moved its positions by frame.
///
public sealed class WorkspaceSequenceSource : ISequenceSource, IProjectRenders
{
private const int JobsListed = 200;
private readonly WorkspaceSync _sync;
private readonly ChronosDatabase _db;
private readonly ImageDecoder _decoder;
private readonly JobEngine? _engine;
private readonly Lock _gate = new();
private readonly List _retired = [];
private IRenderFrameSource? _frames;
private IFrameSource? _pixels;
private int _frameCount;
private int _framesVersion = -1;
private Guid[] _frameIds = [];
private FramePhotos _photos = new([]);
private BundleWorkspace? _workspace;
private bool _readOnly;
private int _disposed;
public WorkspaceSequenceSource(WorkspaceSync sync, Guid projectId, ChronosDatabase db, ImageDecoder decoder, JobEngine? engine)
{
ArgumentNullException.ThrowIfNull(sync);
ArgumentNullException.ThrowIfNull(db);
ArgumentNullException.ThrowIfNull(decoder);
_sync = sync;
_db = db;
_decoder = decoder;
_engine = engine;
ProjectId = projectId;
if (engine is not null) engine.JobChanged += OnJobChanged;
}
public Guid ProjectId { get; }
/// The project's folder in the workspace.
public WorkspaceProject Project => _sync.Store.Project(ProjectId);
/// The workspace section of the project file as read last (name, Main, home, base, media); null before the first read.
public BundleWorkspace? Workspace => Volatile.Read(ref _workspace);
/// The frames version of the home the media read last were copied at; -1 before the first read.
public int MediaFramesVersion => Volatile.Read(ref _framesVersion);
/// The photos of the media read last, in frame order (what positions name).
public FramePhotos Photos => Volatile.Read(ref _photos);
public bool IsRemote => false;
/// Settings of a newer Chronos: shown, never saved.
public bool IsReadOnly => Volatile.Read(ref _readOnly);
public bool IsOutdated => false;
/// A workspace project's read-only state is known when it opens.
public event Action? ReadOnlyChanged
{
add { }
remove { }
}
public event Action? JobChanged;
/// The workspace holds no media for the project (copy them again), or the project is gone.
public async Task LoadAsync(CancellationToken cancellationToken)
{
WorkspaceSession session;
try
{
session = await _sync.OpenAsync(ProjectId, cancellationToken);
}
catch (InvalidOperationException ex)
{
throw new EditorException(Loc.L("Errors.Workspace.NotCheckedOut"), ex);
}
catch (InvalidDataException ex)
{
throw new EditorException(Loc.L("Editor.Error.Project"), ex);
}
if (session is not { Sequence: { } media, Media: { } index }) throw new EditorException(Loc.L("Errors.Workspace.MediaMissing"));
var home = session.Bundle.Workspace!.Home;
var row = await _db.Sequences.GetAsync(home.SequenceId, cancellationToken);
var archive = row is null ? null : await _db.Archives.GetAsync(row.ArchiveId, cancellationToken);
IReadOnlyList renders = row is null ? [] : await _db.Renders.ListBySequenceAsync(home.SequenceId, cancellationToken);
return await Task.Run(() =>
{
var frames = media.Frames;
Swap(media, index, session.Bundle.Workspace!, session.IsReadOnly);
var times = frames.Where(f => f.CapturedAt is not null).Select(f => f.CapturedAt!.Value).Order().ToList();
// The home's row (camera, interval, tags) with the frames this workspace holds.
var sequence = (row ?? media.Sequence) with
{
FrameCount = frames.Count,
FramesVersion = index.FramesVersion,
FirstCapture = times.Count > 0 ? times[0] : null,
LastCapture = times.Count > 0 ? times[^1] : null,
SettingsJson = session.Working.ToJson(),
};
var folder = archive is null ? null : new ArchivePaths(archive.RootPath).Sequence(row!.Folder);
var (deep, otherFrames) = ReadReport(folder, row?.FramesVersion == index.FramesVersion, session.Project.AnalysisPath, frames.Count);
var context = SequenceContext.FromFrames(frames);
return new SequenceContent(sequence, frames, session.Working, LightAnalyzer.Analyze(frames), deep, context.SourceWidth, context.SourceHeight,
folder?.Exports, [.. renders.OrderByDescending(r => r.Created)], [])
{
DeepOfOtherFrames = otherFrames,
};
}, cancellationToken);
}
/// Only a copy job changes the workspace's frames (Update media): its media index is compared with the one read last.
public Task FramesCurrentAsync(CancellationToken cancellationToken) => Task.Run(() =>
{
var (framesVersion, ids) = (Volatile.Read(ref _framesVersion), Volatile.Read(ref _frameIds));
try
{
return Project.ReadMedia() is { } media && media.FramesVersion == framesVersion && media.Frames.Select(f => f.Id).SequenceEqual(ids);
}
catch (InvalidDataException ex)
{
Log.Warning("editor", $"The media index of workspace project {ProjectId} cannot be read", ex);
return false;
}
}, cancellationToken);
/// Whether the home's frames moved past those the workspace holds (frames added or removed there): "Update media" copies them again.
public async Task HomeFramesChangedAsync(CancellationToken cancellationToken)
{
if (Workspace is not { } workspace || MediaFramesVersion < 0) return false;
return await _db.Sequences.GetAsync(workspace.Home.SequenceId, cancellationToken) is { } row && row.FramesVersion != MediaFramesVersion;
}
public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken)
{
IFrameSource? pixels;
int count;
lock (_gate) (pixels, count) = (_pixels, _frameCount);
if (pixels is null || (uint)index >= (uint)count) return null;
// The loader decodes synchronously: an async delegate keeps a superseded decode's cancellation in user code (R4).
return await Task.Run(async () => await pixels.LoadAsync(index, maxLongEdge, cancellationToken).ConfigureAwait(false), cancellationToken);
}
/// The project is read-only, or its media are gone.
/// The media changed since they were read (a copy job): read them again first.
public Task SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken)
{
ArgumentNullException.ThrowIfNull(project);
ArgumentNullException.ThrowIfNull(basis);
var framesVersion = Volatile.Read(ref _framesVersion);
if (framesVersion < 0) throw new InvalidOperationException("LoadAsync first.");
var folder = Project;
return Task.Run(async () =>
{
using (await folder.LockAsync(_sync.LockWait, cancellationToken))
{
var bundle = folder.ReadBundle();
if (bundle.IsReadOnly || project.IsNewerFormat) throw new EditorException(Loc.L("Errors.Workspace.ReadOnly"));
var media = folder.ReadMedia() ?? throw new EditorException(Loc.L("Errors.Workspace.MediaMissing"));
// A copy job moved the working state onto other frames: the editor reads them and moves its positions first.
if (media.FramesVersion != framesVersion) throw new FramesChangedException(Loc.L("Errors.Workspace.MediaChanged"));
var stored = ProjectSettings.FromJson(ProjectContent.Place(bundle.Project.ToJson(), media.Photos), allowNewer: true);
var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored);
if (ProjectMerge.SameValues(merged, stored)) return merged;
folder.WriteBundle(bundle with { Project = merged, Saved = DateTimeOffset.UtcNow });
return merged;
}
}, cancellationToken);
}
public async Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken)
{
if (_engine is null) throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"));
var job = await _engine.EnqueueAsync(request, cancellationToken: cancellationToken);
return job.Id;
}
public async Task> ListJobsAsync(CancellationToken cancellationToken) =>
(await _db.Jobs.ListAsync(null, JobsListed, null, cancellationToken)).Items;
public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken) =>
(_engine ?? throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"))).CancelAsync(jobId, cancellationToken);
public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken) =>
(_engine ?? throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"))).ResumeAsync(jobId, cancellationToken);
///
/// The render at the home (owner review 2, R8: edit with proxies, render where the originals are): one job of this PC's
/// engine per preset, with the project's portable settings (positions parked by photo, placed on the home's frames by
/// the render) and the project recorded on the render; the version too when the settings are those of the last
/// version the home holds (an unsaved working state, or one saved here and not sent yet, renders as it is, without a version).
///
public IReadOnlyList RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight)
{
ArgumentNullException.ThrowIfNull(sequence);
ArgumentNullException.ThrowIfNull(project);
ArgumentNullException.ThrowIfNull(export);
var portable = ProjectContent.ToPortable(project with { Export = export }, Photos);
var hash = ProjectContent.Hash(portable);
var (tipId, tipHash) = Tip();
var version = new ProjectVersion
{
Id = tipId ?? Guid.Empty,
ProjectId = ProjectId,
Number = 0,
SettingsJson = portable,
ContentHash = hash,
};
var requests = ProcessingJobs.RenderVersion(sequence, version, export, sourceWidth, sourceHeight);
if (tipId is not null && string.Equals(tipHash, hash, StringComparison.OrdinalIgnoreCase)) return requests;
return [.. requests.Select(r => r with { ParametersJson = WithoutVersion(r.ParametersJson) })];
}
public async ValueTask DisposeAsync()
{
if (Interlocked.Exchange(ref _disposed, 1) == 1) return;
if (_engine is not null) _engine.JobChanged -= OnJobChanged;
List sources;
lock (_gate)
{
sources = [.. _retired];
if (_frames is not null) sources.Add(_frames);
_retired.Clear();
(_frames, _pixels) = (null, null);
}
foreach (var source in sources)
{
if (source is IAsyncDisposable disposable) await disposable.DisposeAsync();
}
}
///
/// Takes the media read now: a frame source over them when they differ from those read before (the old one is disposed
/// with this source, as a decode may still read it), their frames and photos, the project's workspace section.
///
private void Swap(WorkspaceSequence media, WorkspaceMedia index, BundleWorkspace workspace, bool readOnly)
{
var ids = media.Frames.Select(f => f.Id).ToArray();
lock (_gate)
{
if (_frames is null || index.FramesVersion != _framesVersion || !ids.AsSpan().SequenceEqual(_frameIds))
{
if (_frames is not null) _retired.Add(_frames);
_frames = media.OpenFrames(_decoder);
_pixels = (IFrameSource)_frames;
_frameCount = media.Frames.Count;
}
_frameIds = ids;
_framesVersion = index.FramesVersion;
_photos = index.Photos;
_workspace = workspace;
_readOnly = readOnly;
}
}
///
/// The version a render may name, with its content hash: the base, which the home holds, while no version waits to be
/// sent; none otherwise. A version not sent yet may never reach the home under its id (a replay or a save-both sends it
/// under another), so a render of it names the project alone.
///
private (Guid? Id, string? Hash) Tip()
{
try
{
if (_sync.Unpushed(ProjectId).Count > 0) return (null, null);
return Project.ReadBundle().Workspace?.Base is { } basis ? (basis.VersionId, basis.ContentHash) : (null, null);
}
catch (Exception ex) when (ex is IOException or InvalidDataException or InvalidOperationException)
{
Log.Warning("editor", $"The versions of workspace project {ProjectId} cannot be read; the render names none", ex);
return (null, null);
}
}
private static string? WithoutVersion(string? parametersJson)
{
if (parametersJson is null || JsonSerializer.Deserialize(parametersJson, ProtocolJson.Default.RenderJobParameters) is not { } parameters) return parametersJson;
return JsonSerializer.Serialize(parameters with { ProjectVersionId = null }, ProtocolJson.Default.RenderJobParameters);
}
///
/// The deep report the editor shows: the home's while its frames are the workspace's, else the copy the workspace took;
/// whether one of another number of frames was read instead.
///
private static (DeepAnalysisReport? Report, bool OtherFrames) ReadReport(SequencePaths? home, bool sameFrames, string copied, int frameCount)
{
var otherFrames = false;
foreach (var path in new[] { sameFrames ? home?.AnalysisPath : null, copied })
{
if (path is null || !File.Exists(path)) continue;
try
{
var report = DeepAnalysisReport.Load(path);
if (report.FrameCount == frameCount) return (report, false);
otherFrames = true;
}
catch (Exception ex) when (ex is IOException or InvalidDataException or JsonException or UnauthorizedAccessException)
{
Log.Warning("editor", $"{path} cannot be read", ex);
}
}
return (null, otherFrames);
}
private void OnJobChanged(Job job) => JobChanged?.Invoke(job);
}