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;
}
}
}