using System.Collections.Concurrent; using System.Collections.ObjectModel; using System.Net; using System.Windows.Input; using System.Windows.Threading; using Titano.App.Infrastructure; using Titano.App.Shell; using Titano.Core.Diagnostics; using Titano.Core.Localization; using Titano.Core.Model; using Titano.Data.Jobs; using Titano.Data.Sync; using Titano.Protocol.Client; using Titano.Ui.Mvvm; namespace Titano.App.Server; /// A filter chip of the sync table: "Conflicts · 1". public sealed class SyncFilterChip(SyncFilter filter, Action select) : ObservableObject { private int _count; private bool _isSelected; public SyncFilter Filter { get; } = filter; public string Text => Loc.L("Server.Sync.Filter." + Filter, Formatting.Count(_count)); public string ToolTip => Loc.L("Tooltips.Server.Sync.Filter." + Filter); public ICommand SelectCommand { get; } = new RelayCommand(() => select(filter)); /// Conflicts waiting for a choice: the chip is drawn in the warning colour. public bool NeedsAttention => Filter == SyncFilter.Conflicts && _count > 0; public bool IsSelected { get => _isSelected; set => Set(ref _isSelected, value); } public int Count { get => _count; set { if (!Set(ref _count, value)) return; OnPropertyChanged(nameof(Text)); OnPropertyChanged(nameof(NeedsAttention)); } } } /// /// The sync table of the Server screen (BRIEF §12.7, Server.html): every sequence of this PC and of the signed-in /// server with what each side holds, where it stands and what can be done (upload, download originals, open with /// proxies, settle a settings conflict, pause or resume a transfer), filter chips, search, "Upload all local" and the /// footer (last comparison, server archive, admin panel). Reloads when the sync engine reports a change; transfer /// progress is applied at most a few times a second. Runs on the UI thread. /// public sealed class SyncTableViewModel : ObservableObject, IDisposable { private readonly ShellViewModel _shell; private readonly IReadOnlyList _chips; private readonly HashSet _openWhenCached = []; private readonly ConcurrentDictionary _progress = new(); private readonly SemaphoreSlim _reloading = new(1, 1); private IReadOnlyList _entries = []; private SyncFilter _filter = SyncFilter.All; private string _search = string.Empty; private int _progressQueued; private int _reloadQueued; private bool _attached; public SyncTableViewModel(ShellViewModel shell) { _shell = shell; _chips = [.. Enum.GetValues().Select(f => new SyncFilterChip(f, Select) { IsSelected = f == SyncFilter.All })]; UploadAllCommand = new AsyncRelayCommand(UploadAllAsync, () => Rights.CanUpload && LocalOnly.Any()); OpenAdminCommand = new RelayCommand(() => { if (Host.Server is { } server) ShellActions.OpenUrl(server + "/admin"); }); } public ObservableCollection Rows { get; } = []; public IReadOnlyList Chips => _chips; public ICommand UploadAllCommand { get; } public ICommand OpenAdminCommand { get; } public string SearchText { get => _search; set { if (Set(ref _search, value ?? string.Empty)) ApplyFilter(); } } /// Signed in: the table compares this PC with that server. public bool IsActive => Host.Server is not null; public bool HasRows => Rows.Count > 0; /// "Not connected to a server", "Nothing to compare yet" or "No sequence matches"; null when rows show. public string? EmptyText => HasRows ? null : !IsActive ? Loc.L("Server.Empty") : _entries.Count == 0 ? Loc.L("Server.Sync.Empty") : Loc.L("Server.Sync.NoMatch"); public string UploadAllToolTip => Loc.L("Tooltips.Server.Sync.UploadAll", Formatting.Count(LocalOnly.Count()), Formatting.Bytes(LocalOnly.Sum(e => e.Local!.TotalBytes))); /// "Last sync 10:15 · manifest diff 0.4 s"; null before the first comparison. public string? LastSyncText => Host.Agent?.Snapshot is { } s ? Loc.L("Server.Sync.Last", Formatting.TimeOfDay(s.RefreshedAt), s.Duration.TotalSeconds.ToString("0.0", Loc.Culture)) : null; /// "Server archive 9.4 TB · 412 sequences". public string? ArchiveText => Host.Agent?.Snapshot is { } s ? Loc.Plural("Server.Sync.Archive", s.ServerSequences, Formatting.Bytes(s.ServerBytes)) : null; /// The last comparison failed (it is retried with growing pauses); null when it worked. public string? ErrorText => Host.Agent?.LastError is not null ? Loc.L("Server.Sync.Retrying") : null; public string? ErrorToolTip => Host.Agent?.LastError is { } error ? Loc.L("Tooltips.Server.Sync.Retrying", error.Message) : null; /// The server's web admin (it admits administrators only). public bool CanOpenAdmin => IsActive; private SyncHost Host => _shell.Services.Sync; private SyncRights Rights => _shell.Services.Server.User is { } user ? SyncRights.Of(user.Permissions) : default; private IEnumerable LocalOnly => _entries.Where(e => e.Status == SyncStatus.LocalOnly); /// Starts following the sync engine and the transfer jobs. public void Attach() { if (_attached) return; _attached = true; Host.Changed += OnChanged; if (_shell.Services.Jobs is { } jobs) { jobs.JobChanged += OnJobChanged; jobs.Progress += OnProgress; } _ = ReloadAsync(); } /// Reads the table again; concurrent requests collapse into one more pass. public async Task ReloadAsync() { Interlocked.Exchange(ref _reloadQueued, 1); if (!await _reloading.WaitAsync(0)) return; try { while (Interlocked.Exchange(ref _reloadQueued, 0) == 1) { _entries = Host is { Service: { } service, Server: { } server } ? await service.ListAsync(server, CancellationToken.None) : []; Refresh(); } } catch (Exception ex) when (ex is Data.DatabaseException or InvalidOperationException) { Log.Warning("sync", "The sync table could not be read", ex); } finally { _reloading.Release(); } } public void Dispose() { if (!_attached) return; Host.Changed -= OnChanged; if (_shell.Services.Jobs is { } jobs) { jobs.JobChanged -= OnJobChanged; jobs.Progress -= OnProgress; } } private void Select(SyncFilter filter) { _filter = filter; foreach (var chip in _chips) chip.IsSelected = chip.Filter == filter; ApplyFilter(); } /// Counts, rows, footer and the Library's sync glyphs after a reload. private void Refresh() { foreach (var chip in _chips) chip.Count = _entries.Count(e => SyncText.Matches(e, chip.Filter, string.Empty)); ApplyFilter(); UpdateLibrary(); OpenCachedProxies(); OnPropertyChanged(nameof(IsActive)); OnPropertyChanged(nameof(UploadAllToolTip)); OnPropertyChanged(nameof(LastSyncText)); OnPropertyChanged(nameof(ArchiveText)); OnPropertyChanged(nameof(ErrorText)); OnPropertyChanged(nameof(ErrorToolTip)); OnPropertyChanged(nameof(CanOpenAdmin)); CommandManager.InvalidateRequerySuggested(); } /// Updates the rows in place (scroll position and recycled containers survive), adding and removing as needed. private void ApplyFilter() { var rights = Rights; var wanted = _entries.Where(e => SyncText.Matches(e, _filter, _search.Trim())).ToList(); var byId = Rows.ToDictionary(r => r.Id); for (var i = 0; i < wanted.Count; i++) { var entry = wanted[i]; if (byId.Remove(entry.Id, out var row)) { row.Update(entry, rights); var at = Rows.IndexOf(row); if (at != i) Rows.Move(at, i); } else { Rows.Insert(i, new SyncRow(entry, rights, ActAsync)); } } while (Rows.Count > wanted.Count) Rows.RemoveAt(Rows.Count - 1); OnPropertyChanged(nameof(HasRows)); OnPropertyChanged(nameof(EmptyText)); } /// The Library shows each local copy's sync state: rows it has loaded take the fresh state. private void UpdateLibrary() { var locals = _entries.Where(e => e.Local is not null).ToDictionary(e => e.Local!.Id, e => e.Local!); foreach (var item in _shell.Library.Items) { if (locals.TryGetValue(item.Id, out var fresh) && fresh.SyncState != item.Sequence.SyncState) item.Update(fresh); } } /// "Open with proxies" waits for the proxy download; the editor opens once it is in the cache. private void OpenCachedProxies() { foreach (var entry in _entries) { if (entry.Status == SyncStatus.ProxiesOnly && _openWhenCached.Remove(entry.Id)) _shell.OpenSequence(entry.Id); } } private async Task ActAsync(SyncRow row, SyncAction action) { if (Host is not { Service: { } service, Server: { } server } || _shell.Services.Engine is not { } engine) return; var entry = row.Entry; switch (action) { case SyncAction.Upload: await service.EnqueueUploadAsync(engine, server, entry.Local!); break; case SyncAction.DownloadOriginals: if ((entry.Local?.ArchiveId ?? (await Host.CurrentArchiveAsync())?.Id) is not { } archive) { _shell.Notify(Loc.L("Errors.Sync.NoArchive")); return; } await service.EnqueueDownloadAsync(engine, server, entry.Id, entry.Title, SyncDownloadMode.Originals, archive); break; case SyncAction.OpenWithProxies when entry.Status == SyncStatus.ProxiesOnly && service.OpenRemote(server, entry.Id) is not null: _shell.OpenSequence(entry.Id); return; case SyncAction.OpenWithProxies: _openWhenCached.Add(entry.Id); await service.EnqueueDownloadAsync(engine, server, entry.Id, entry.Title, SyncDownloadMode.Proxies, null); break; case SyncAction.Pause: await _shell.Services.Jobs!.PauseAsync(entry.Transfer!.Id); break; case SyncAction.Resume: await _shell.Services.Jobs!.ResumeAsync(entry.Transfer!.Id); break; case SyncAction.SyncSettings when Host.Remote is { } remote: await service.SyncSettingsAsync(remote, entry.Id, CancellationToken.None); break; case SyncAction.KeepMine or SyncAction.TakeServer or SyncAction.SaveBoth when Host.Remote is { } remote: await ResolveAsync(service, remote, entry, action); break; } await ReloadAsync(); } /// Settles a conflict; overwriting one side is confirmed first with the settings that differ (the dry run). private async Task ResolveAsync(SyncService service, ISyncRemote remote, SyncEntry entry, SyncAction action) { var resolution = action switch { SyncAction.KeepMine => SyncResolution.KeepMine, SyncAction.TakeServer => SyncResolution.TakeServer, _ => SyncResolution.SaveBoth, }; if (resolution != SyncResolution.SaveBoth && !_shell.Services.Dialogs.Confirm(new ConfirmRequest { Heading = Loc.L("Server.Conflict." + action + ".Title"), Message = Loc.L("Server.Conflict." + action + ".Message", entry.Title), Detail = SyncText.Conflict(entry), DetailToolTip = Loc.L("Tooltips.Server.Conflict.Detail"), SafeText = Loc.L("Server.Conflict.Cancel"), SafeToolTip = Loc.L("Tooltips.Server.Conflict.Cancel"), ActionText = Loc.L("Server.Sync.Action." + action), ActionToolTip = Loc.L("Tooltips.Server.Sync." + action), IsDestructive = true, })) return; try { await service.ResolveAsync(remote, entry.Id, resolution, CancellationToken.None); } catch (TitanoApiException ex) when (ex.Status == HttpStatusCode.Conflict) { // The server copy changed again meanwhile: compare again and let the user choose on fresh content. _shell.Notify(Loc.L("Server.Sync.ChangedAgain")); await service.RefreshSequencesAsync(remote, [entry.Id], Host.Policy, CancellationToken.None); } } private async Task UploadAllAsync() { if (Host is not { Service: { } service, Server: { } server } || _shell.Services.Engine is not { } engine) return; var queued = 0; foreach (var entry in LocalOnly.ToList()) { await service.EnqueueUploadAsync(engine, server, entry.Local!); queued++; } _shell.Notify(Loc.Plural("Server.Sync.Queued", queued)); await ReloadAsync(); } private void OnChanged() => Dispatch(() => _ = ReloadAsync()); private void OnJobChanged(Job job) { if (job.Kind is not (JobKind.UploadCommit or JobKind.Download)) return; _progress.TryRemove(job.Id, out _); OnChanged(); } /// Transfer progress ("46 % received") without reading the table again, at most a few times a second. private void OnProgress(JobProgressInfo info) { if (info.Kind is not (JobKind.UploadCommit or JobKind.Download)) return; _progress[info.JobId] = info; if (Interlocked.Exchange(ref _progressQueued, 1) == 1) return; System.Windows.Application.Current?.Dispatcher.BeginInvoke(DispatcherPriority.Background, async () => { await Task.Delay(250); Interlocked.Exchange(ref _progressQueued, 0); var rights = Rights; foreach (var row in Rows) { if (row.Entry.Transfer is { } job && _progress.TryGetValue(job.Id, out var p)) row.Update(row.Entry with { Transfer = job with { ProgressDone = p.Done, ProgressTotal = p.Total } }, rights); } }); } private static void Dispatch(Action action) { if (System.Windows.Application.Current?.Dispatcher is not { } dispatcher || dispatcher.CheckAccess()) action(); else dispatcher.BeginInvoke(action); } }