using System.Collections.ObjectModel; using System.Windows.Input; using Chronos.App.Archiving; using Chronos.App.Infrastructure; using Chronos.App.Settings; using Chronos.Core.Diagnostics; using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data.Projects; using Chronos.Data.Workspaces; using Chronos.Ui.Mvvm; namespace Chronos.App.Workspace; /// What "Open in workspace" chose: an existing project of the home () or a new one (), and the media. public sealed record OpenChoice(Guid? ProjectId, string? NewName, string Media); /// A project of the home offered by "Open in workspace" (Main in the UI language). public sealed record ProjectOption(SequenceProject Project) { public string Label => WorkspaceText.ProjectName(Project.Name, Project.IsMain); public override string ToString() => Label; } /// Project names as the home takes them: 1 to 60 characters, no control character, each once per sequence (case does not count). public static class ProjectNames { /// The problem of , or null when the home takes it. public static string? Validate(string name, IEnumerable others) { var trimmed = name?.Trim() ?? string.Empty; if (trimmed.Length is 0 or > ProjectService.MaxNameLength || trimmed.Any(char.IsControl)) return Loc.L("Errors.Workspace.InvalidName"); return others.Any(o => string.Equals(o, trimmed, StringComparison.OrdinalIgnoreCase)) ? Loc.L("Errors.Workspace.NameTaken") : null; } } /// /// "Open in workspace" (owner review 2, R8), asked when a sequence has no project in the workspace yet, and by the project /// menu's Open project: which project of its home (Main, made from the sequence's settings as they are, or another) or a /// new one with its name, and the media to copy (proxies; the originals come in phase 5c). Open queues the copy; the /// sequence opens once it is done. /// public sealed class OpenInWorkspaceDialogViewModel : ArchiveDialogViewModel { private readonly TaskCompletionSource _choice = new(TaskCreationOptions.RunContinuationsAsynchronously); private ProjectOption? _selected; private bool _isNew; /// The names a new project cannot take (default: those of ). public OpenInWorkspaceDialogViewModel(string sequenceTitle, IReadOnlyList projects, Action close, IReadOnlyList? taken = null) : base(close) { SequenceTitle = sequenceTitle; Projects = [.. projects.OrderByDescending(p => p.IsMain).Select(p => new ProjectOption(p))]; _selected = Projects.FirstOrDefault(); _isNew = Projects.Count == 0; var names = taken ?? [.. projects.Select(p => p.Name)]; NewName = new EditableField(string.Empty, n => ProjectNames.Validate(n, names), _ => { }, () => Loc.L("Tooltips.Editor.OpenWorkspace.Name")); NewName.PropertyChanged += (_, _) => Refresh(); OpenCommand = new RelayCommand(Open, () => CanOpen); } /// Completes with the user's choice, or null when the dialog was closed without one. public Task Choice => _choice.Task; public string SequenceTitle { get; } public string Heading => Loc.L("Editor.OpenWorkspace.Title"); public IReadOnlyList Projects { get; } public bool HasProjects => Projects.Count > 0; public ProjectOption? SelectedProject { get => _selected; set { if (Set(ref _selected, value) && value is not null) IsExisting = true; } } /// A project the home has. public bool IsExisting { get => !_isNew; set { if (value) IsNew = false; } } /// A new project, named in . public bool IsNew { get => _isNew; set { if (!Set(ref _isNew, value || !HasProjects)) return; OnPropertyChanged(nameof(IsExisting)); Refresh(); } } public EditableField NewName { get; } /// The proxies, the only media this phase copies. public bool IsProxies => true; /// The originals: offered from phase 5c, to render on this PC. public bool CanCopyOriginals => false; public ICommand OpenCommand { get; } public bool CanOpen => _isNew ? !NewName.HasErrors : _selected is not null; public string OpenToolTip => _isNew && NewName.Error is { } error ? error : Loc.L("Tooltips.Editor.OpenWorkspace.Open"); public override void Dispose() { // Closed without a choice (Cancel, Esc, another sequence asked for). _choice.TrySetResult(null); base.Dispose(); } private void Open() { if (!CanOpen) return; _choice.TrySetResult(_isNew ? new OpenChoice(null, NewName.Text.Trim(), BundleMedia.Proxies) : new OpenChoice(_selected!.Project.Id, null, BundleMedia.Proxies)); Close(); } private void Refresh() { OnPropertyChanged(nameof(CanOpen)); OnPropertyChanged(nameof(OpenToolTip)); CommandManager.InvalidateRequerySuggested(); } } /// Names a project: "New project" (made from the open project's last version at the home) or "Rename". public sealed class ProjectNameDialogViewModel : ArchiveDialogViewModel { private readonly Func _save; /// The names of the sequence's other projects (each name is used once). public ProjectNameDialogViewModel(bool rename, string name, IEnumerable others, Func save, Action close) : base(close) { IsRename = rename; _save = save; var taken = others.ToList(); Name = new EditableField(name, n => ProjectNames.Validate(n, taken), _ => { }, () => Loc.L("Tooltips.Editor.ProjectName.Name")); Name.PropertyChanged += (_, _) => { OnPropertyChanged(nameof(SaveToolTip)); CommandManager.InvalidateRequerySuggested(); }; SaveCommand = new AsyncRelayCommand(SaveAsync, () => !IsBusy && !Name.HasErrors); } public bool IsRename { get; } public string Heading => Loc.L(IsRename ? "Editor.ProjectName.Rename" : "Editor.ProjectName.New"); public string SaveText => Loc.L(IsRename ? "Editor.ProjectName.Apply" : "Editor.ProjectName.Create"); public EditableField Name { get; } public ICommand SaveCommand { get; } public string SaveToolTip => Name.Error ?? Loc.L(IsRename ? "Tooltips.Editor.ProjectName.Apply" : "Tooltips.Editor.ProjectName.Create"); private async Task SaveAsync() { ClearError(); IsBusy = true; try { await _save(Name.Text.Trim()); Close(); } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("workspace", "Naming a project failed", ex); ShowMessage(WorkspaceText.Failure(ex), ex.Message); } finally { IsBusy = false; } } } /// "Save version" (Ctrl+S): an optional note, then the version is saved (and sent when Sync automatically is on). public sealed class SaveVersionDialogViewModel : ArchiveDialogViewModel { /// A note is a line of the history: longer text is cut there. public const int MaxNoteLength = 200; private readonly Func _save; private string _note = string.Empty; public SaveVersionDialogViewModel(string projectName, Func save, Action close) : base(close) { ProjectName = projectName; _save = save; SaveCommand = new AsyncRelayCommand(SaveAsync, () => !IsBusy); } public string ProjectName { get; } public string Heading => Loc.L("Editor.SaveVersion.Title", ProjectName); public string Note { get => _note; set => Set(ref _note, (value ?? string.Empty).Length > MaxNoteLength ? value![..MaxNoteLength] : value ?? string.Empty); } public ICommand SaveCommand { get; } private async Task SaveAsync() { ClearError(); IsBusy = true; try { await _save(string.IsNullOrWhiteSpace(_note) ? null : _note.Trim()); Close(); } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("workspace", "Saving a version failed", ex); ShowMessage(WorkspaceText.Failure(ex), ex.Message); } finally { IsBusy = false; } } } /// A version in the History flyout: number, author, time, note, what made it, and Compare and Restore. public sealed class HistoryRowViewModel(ProjectVersion version, bool unsent, bool isCurrent, ICommand compare, ICommand restore) : ObservableObject { public ProjectVersion Version { get; } = version; public string Number => Formatting.Count(Version.Number); public string Author => WorkspaceText.Author(Version); public string When => WorkspaceText.When(Version.CreatedAt); public string Note => Version.Note ?? string.Empty; public string KindText => WorkspaceText.VersionKind(Version.Kind); /// Saved here, waiting to be sent. public bool IsUnsent { get; } = unsent; /// The version the working state was last saved as (nothing differs). public bool IsCurrent { get; } = isCurrent; /// "Version 3 · Saved · STUDIO-PC · 28/10/2026 18:02 · note": the row for screen readers and its tooltip. public string Description => string.Join(Loc.Separator, new[] { Loc.L("Editor.History.Version", Number), KindText, Author, When, Note }.Where(s => s.Length > 0)); public ICommand CompareCommand { get; } = compare; public ICommand RestoreCommand { get; } = restore; public string CompareToolTip => Loc.L("Tooltips.Editor.History.Compare", Number); public string RestoreToolTip => Loc.L("Tooltips.Editor.History.Restore", Number); } /// /// The History flyout of a workspace project: its versions newest first (those not sent yet marked), Compare (the /// settings that differ from the project now) and Restore (the version as the project again, one undo step). /// public sealed class HistoryDialogViewModel : ArchiveDialogViewModel { private readonly Func>> _compare; private readonly Func _restore; private string? _comparedTitle; private IReadOnlyList _compared = []; private bool _isLoaded; public HistoryDialogViewModel(string projectName, Func>> compare, Func restore, Action close) : base(close) { ProjectName = projectName; _compare = compare; _restore = restore; } public string ProjectName { get; } public string Heading => Loc.L("Editor.History.Title", ProjectName); public ObservableCollection Rows { get; } = []; /// The home could not be asked: only this PC's versions are listed. public bool IsOffline { get; private set; } public bool IsEmpty => _isLoaded && Rows.Count == 0; /// "Version 3 → now" over the comparison; null before one. public string? ComparedTitle { get => _comparedTitle; private set => Set(ref _comparedTitle, value); } public IReadOnlyList Compared { get => _compared; private set => Set(ref _compared, value); } /// Lists ; marks the version the project is now. public void Show(WorkspaceHistory history, string? currentHash) { ArgumentNullException.ThrowIfNull(history); Rows.Clear(); foreach (var version in history.Versions) { var current = currentHash is not null && string.Equals(version.ContentHash, currentHash, StringComparison.OrdinalIgnoreCase); Rows.Add(new HistoryRowViewModel(version, history.Unsent.Contains(version.Id), current, new AsyncRelayCommand(() => CompareAsync(version), () => !IsBusy), new AsyncRelayCommand(() => RestoreAsync(version), () => !IsBusy))); } IsOffline = history.Offline; _isLoaded = true; OnPropertyChanged(nameof(IsOffline)); OnPropertyChanged(nameof(IsEmpty)); } /// A failure of the read that lists the versions, shown in the flyout. public void ShowFailure(Exception ex) { ArgumentNullException.ThrowIfNull(ex); _isLoaded = true; OnPropertyChanged(nameof(IsEmpty)); ShowMessage(WorkspaceText.Failure(ex), ex.Message); } public async Task CompareAsync(ProjectVersion version) { ArgumentNullException.ThrowIfNull(version); ClearError(); try { var lines = await _compare(version); ComparedTitle = Loc.L("Editor.History.Compared", Formatting.Count(version.Number)); Compared = lines.Count == 0 ? [Loc.L("Editor.History.Same")] : lines; } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("workspace", $"Version {version.Number} could not be compared", ex); ShowMessage(WorkspaceText.Failure(ex), ex.Message); } } public async Task RestoreAsync(ProjectVersion version) { ArgumentNullException.ThrowIfNull(version); ClearError(); IsBusy = true; try { await _restore(version); IsBusy = false; Close(); } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("workspace", $"Version {version.Number} could not be restored", ex); ShowMessage(WorkspaceText.Failure(ex), ex.Message); IsBusy = false; } } } /// /// A sync that met settings both sides changed (owner review 2, R8: asked only on real conflicts): what differs, then /// Keep mine, Take the library's, or Save both (this workspace's versions go to a sibling project). Later leaves the /// conflict for the next Sync; editing goes on meanwhile. /// public sealed class ConflictDialogViewModel : ArchiveDialogViewModel { private readonly Func _resolve; public ConflictDialogViewModel(string projectName, string siblingName, IReadOnlyList differences, Func resolve, Action close) : base(close) { ProjectName = projectName; SiblingName = siblingName; Differences = differences; _resolve = resolve; KeepMineCommand = new AsyncRelayCommand(() => ResolveAsync(ConflictChoice.KeepMine), () => !IsBusy); TakeHomeCommand = new AsyncRelayCommand(() => ResolveAsync(ConflictChoice.TakeServer), () => !IsBusy); SaveBothCommand = new AsyncRelayCommand(() => ResolveAsync(ConflictChoice.SaveBoth), () => !IsBusy); } public string ProjectName { get; } /// The project Save both makes for this workspace's versions. public string SiblingName { get; } public string Heading => Loc.L("Editor.Workspace.Conflict.Title"); public string Message => Loc.L("Editor.Workspace.Conflict.Message", ProjectName); public IReadOnlyList Differences { get; } public ICommand KeepMineCommand { get; } public ICommand TakeHomeCommand { get; } public ICommand SaveBothCommand { get; } public string SaveBothToolTip => Loc.L("Tooltips.Editor.Workspace.SaveBoth", SiblingName); private async Task ResolveAsync(ConflictChoice choice) { ClearError(); IsBusy = true; try { await _resolve(choice); IsBusy = false; Close(); } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("workspace", $"The conflict of '{ProjectName}' could not be settled ({choice})", ex); ShowMessage(WorkspaceText.Failure(ex), ex.Message); IsBusy = false; } } } /// /// "Remove local copy": the plan (files and size of the copy; versions not sent and changes not saved), then Remove /// (only when everything is at the library), Send first (sends, then removes), or Discard changes (removes once the /// user typed the project's name; the unsent work is kept aside in the workspace's trash). A project the library no /// longer has () can only be discarded that way. /// public sealed class RemoveCopyDialogViewModel : ArchiveDialogViewModel { private readonly Func _remove; private readonly Func _sendFirst; private readonly Func _confirmDiscard; /// The typed confirmation Discard changes asks first (); true when the user confirmed. public RemoveCopyDialogViewModel(WorkspaceRemovalPlan plan, Func remove, Func sendFirst, Func confirmDiscard, Action close) : base(close) { Plan = plan; _remove = remove; _sendFirst = sendFirst; _confirmDiscard = confirmDiscard; Facts = [ new DialogFact(Loc.L("Editor.RemoveCopy.Files"), Formatting.Count(plan.Files)), new DialogFact(Loc.L("Editor.RemoveCopy.Size"), Formatting.Bytes(plan.Bytes)), new DialogFact(Loc.L("Editor.RemoveCopy.Unsent"), Formatting.Count(plan.Unsent)), new DialogFact(Loc.L("Editor.RemoveCopy.Changed"), Loc.L(plan.Modified ? "Editor.RemoveCopy.Yes" : "Editor.RemoveCopy.No")), ]; RemoveCommand = new AsyncRelayCommand(() => RunAsync(() => _remove(false)), () => !IsBusy && plan.IsSafe && !plan.Offline && !plan.Gone); SendFirstCommand = new AsyncRelayCommand(() => RunAsync(_sendFirst), () => !IsBusy && !plan.IsSafe && !plan.Conflict && !plan.Offline && !plan.Gone); DiscardCommand = new AsyncRelayCommand(DiscardAsync, () => !IsBusy && HasUnsent); } public WorkspaceRemovalPlan Plan { get; } public string Heading => Loc.L("Editor.RemoveCopy.Title", WorkspaceText.ProjectName(Plan.Name, false)); public IReadOnlyList Facts { get; } /// Something would not be at the library after the removal (or the library no longer has the project): Discard changes shows. public bool HasUnsent => !Plan.IsSafe || Plan.Gone; public ICommand RemoveCommand { get; } public ICommand SendFirstCommand { get; } public ICommand DiscardCommand { get; } public string RemoveToolTip => Plan.Gone ? Loc.L("Errors.Workspace.ProjectGone") : !Plan.IsSafe ? Loc.L("Errors.Workspace.Unsent") : Plan.Offline ? Loc.L("Errors.Workspace.Offline") : Loc.L("Tooltips.Editor.RemoveCopy.Remove"); public string SendFirstToolTip => Plan.Gone ? Loc.L("Errors.Workspace.ProjectGone") : Plan.Conflict ? Loc.L("Errors.Workspace.Conflict") : Plan.Offline ? Loc.L("Errors.Workspace.Offline") : Loc.L("Tooltips.Editor.RemoveCopy.SendFirst"); public string DiscardToolTip => Loc.L("Tooltips.Editor.RemoveCopy.Discard"); /// /// The typed confirmation of Discard changes (the plan's cross-cutting rule for what Chronos cannot bring back): the /// project's name, as shown, typed before Discard enables. /// public static ConfirmRequest DiscardRequest(string projectName) => new() { Heading = Loc.L("Editor.RemoveCopy.DiscardTitle", projectName), Message = Loc.L("Editor.RemoveCopy.DiscardMessage"), SafeText = Loc.L("Editor.Project.Keep"), SafeToolTip = Loc.L("Tooltips.Editor.RemoveCopy.Keep"), ActionText = Loc.L("Editor.RemoveCopy.Discard"), ActionToolTip = Loc.L("Tooltips.Editor.RemoveCopy.Discard"), IsDestructive = true, TypedConfirmation = projectName, TypedPrompt = Loc.L("Editor.RemoveCopy.TypeName"), }; /// Asks through : true when the user typed the name and confirmed. public static bool ConfirmDiscard(IWorkspaceUi ui, string projectName) { ArgumentNullException.ThrowIfNull(ui); return ui.Confirm(DiscardRequest(projectName)); } private async Task DiscardAsync() { if (!_confirmDiscard()) return; await RunAsync(() => _remove(true)); } private async Task RunAsync(Func action) { ClearError(); IsBusy = true; try { await action(); IsBusy = false; Close(); } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("workspace", $"The local copy of project {Plan.ProjectId} was not removed", ex); ShowMessage(WorkspaceText.Failure(ex), ex.Message); IsBusy = false; } } }