using System.ComponentModel;
using System.Windows.Input;
using Titano.App.Infrastructure;
using Titano.App.Server;
using Titano.App.Shell;
using Titano.Core.Localization;
using Titano.Ui.Controls;
using Titano.Ui.Mvvm;
namespace Titano.App.Sections;
///
/// Server (BRIEF §12.7, Server.html): address with LAN-discovered servers, connect with trust-on-first-use and login,
/// status (name, version, latency, certificate), account and quota, sign out, the options of this PC (render node,
/// proxies kept offline, automatic project sync, uploads paused on metered networks) and the sync table ().
///
public sealed class ServerViewModel : SectionViewModel
{
private string _address;
private string? _errorText;
private ServerSession? _session;
public ServerViewModel(ShellViewModel shell)
: base(SectionKey.Server, "Icon.Server")
{
Shell = shell;
_address = ServerAddress.Display(shell.Services.Settings.ServerUrl);
ConnectCommand = new AsyncRelayCommand(ConnectAsync, () => !IsBusy && !IsConnected && Address.Trim().Length > 0);
DisconnectCommand = new RelayCommand(() => Session.Disconnect(), () => IsConnected);
SignOutCommand = new AsyncRelayCommand(SignOutAsync, () => IsConnected);
UseServerCommand = new RelayCommand(p =>
{
if (p is DiscoveredServer s) Address = s.Address;
else if (p is string text) Address = text;
});
CertificateCommand = new RelayCommand(ShowCertificate, () => Fingerprint is not null);
Sync = new SyncTableViewModel(shell);
}
/// Sequences of this PC and of the server, where they stand and what can be done.
public SyncTableViewModel Sync { get; }
public ShellViewModel Shell { get; }
private ServerSession Session => _session ?? Shell.Services.Server;
public ICommand ConnectCommand { get; }
public ICommand DisconnectCommand { get; }
public ICommand SignOutCommand { get; }
public ICommand UseServerCommand { get; }
public ICommand CertificateCommand { get; }
/// Servers found on the LAN plus recently used ones, for the ▾ list.
public IEnumerable KnownServers =>
Session.Discovered.Concat(Shell.Services.Settings.RecentServers
.Where(r => !Session.Discovered.Any(d => d.Address.Equals(r, StringComparison.OrdinalIgnoreCase)))
.Select(r => new DiscoveredServer(r, r)));
public bool HasKnownServers => KnownServers.Any();
public string Address
{
get => _address;
set
{
if (Set(ref _address, value ?? string.Empty)) CommandManager.InvalidateRequerySuggested();
}
}
public bool IsBusy => Session.IsBusy;
public bool IsConnected => Session.IsConnected;
public bool IsDisconnected => !Session.IsConnected;
/// One sentence about the last failure; null when none.
public string? ErrorText
{
get => _errorText;
private set => Set(ref _errorText, value);
}
// ---- Status row ----
public StatusKind StatusKind => IsConnected ? StatusKind.Online : IsBusy ? StatusKind.Running : ErrorText is null ? StatusKind.Offline : StatusKind.Error;
public string StatusText => IsConnected ? Loc.L("Server.Status.Connected")
: IsBusy ? Loc.L("Server.Status.Connecting")
: Session.HasSavedSession ? Loc.L("Server.Status.Disconnected")
: Loc.L("Server.Status.NotConnected");
/// "Studio NAS · v1.3.0 · 14 ms".
public string? ServerText
{
get
{
if (!IsConnected || Session.Flow.Info is not { } info) return null;
var parts = new List { info.Name, Loc.L("Server.Version", info.Version) };
if (Session.Flow.Latency is { } latency) parts.Add(Loc.L("Server.Latency", Math.Max(1, (int)Math.Round(latency.TotalMilliseconds))));
return string.Join(" · ", parts);
}
}
/// Fingerprint of the trusted self-signed certificate; null for a publicly valid certificate.
public string? Fingerprint => IsConnected ? Session.TrustOf(Session.Flow.Info?.TlsFingerprint)?.Fingerprint : null;
/// "TLS 9A:3C:71:E0:… trusted 2026-09-01".
public string? CertificateText => Fingerprint is { } fp && Session.TrustOf(fp) is { } trust
? Loc.L("Server.Certificate.Trusted", ServerSession.ShortFingerprint(fp), Formatting.Date(trust.TrustedAt))
: null;
public string CertificateToolTip => Loc.L("Tooltips.Server.CertificateTrusted");
// ---- Account row ----
public string? Username => Session.User?.Username;
public string Initial => Username is { Length: > 0 } u ? char.ToUpper(u[0], Loc.Culture).ToString() : string.Empty;
public string? RoleText => Session.User?.Role is { } role ? KnownRole(role) is { } known ? Loc.L("Server.Role." + known) : role : null;
public string? RoleToolTip => Session.User?.Role is { } role && KnownRole(role) is { } known ? Loc.L("Tooltips.Server.Role." + known) : null;
public bool HasQuota => Session.User is { QuotaBytes: > 0 };
public double QuotaFraction => Session.User is { QuotaBytes: > 0 } u ? Math.Clamp((double)u.UsedBytes / u.QuotaBytes, 0, 1) : 0;
/// "2.1 TB of 5 TB", or the used bytes when unlimited.
public string? QuotaText => Session.User is not { } u ? null
: u.QuotaBytes > 0 ? Loc.L("Server.Quota", Formatting.Bytes(u.UsedBytes), Formatting.Bytes(u.QuotaBytes))
: Loc.L("Server.QuotaUnlimited", Formatting.Bytes(u.UsedBytes));
// ---- Options ----
public bool RenderNodeOptIn
{
get => Shell.Services.Settings.RenderNodeOptIn;
set
{
if (Shell.Services.Settings.RenderNodeOptIn == value) return;
Shell.Services.Settings.RenderNodeOptIn = value;
Shell.Services.SaveSettings();
OnPropertyChanged();
}
}
/// Keep the proxy caches of server sequences opened with proxies up to date on this PC.
public bool KeepProxiesOffline
{
get => Shell.Services.Settings.KeepProxiesOffline;
set => SetSyncOption(value, Shell.Services.Settings.KeepProxiesOffline, v => Shell.Services.Settings.KeepProxiesOffline = v);
}
/// Send and take project settings changed on one side without asking.
public bool SyncSettingsAutomatically
{
get => Shell.Services.Settings.SyncSettingsAutomatically;
set => SetSyncOption(value, Shell.Services.Settings.SyncSettingsAutomatically, v => Shell.Services.Settings.SyncSettingsAutomatically = v);
}
/// Pause uploads while the connection is metered.
public bool PauseUploadsOnMetered
{
get => Shell.Services.Settings.PauseUploadsOnMetered;
set
{
if (Shell.Services.Settings.PauseUploadsOnMetered == value) return;
Shell.Services.Settings.PauseUploadsOnMetered = value;
Shell.Services.SaveSettings();
Shell.Services.Sync.Uploads.Request();
OnPropertyChanged();
}
}
/// Re-reads values another screen changed (Settings › Server).
public void Refresh() => OnPropertyChanged(nameof(RenderNodeOptIn));
/// Restores the saved session and starts listening for LAN servers.
public async Task AttachAsync()
{
_session = Shell.Services.Server;
_session.PropertyChanged += OnSessionChanged;
_session.Discovered.CollectionChanged += (_, _) =>
{
OnPropertyChanged(nameof(KnownServers));
OnPropertyChanged(nameof(HasKnownServers));
if (Address.Length == 0 && Session.Discovered.Count > 0) Address = Session.Discovered[0].Address;
};
if (!Shell.Services.Environment.IsCapture) _session.StartDiscovery();
Sync.Attach();
await _session.RestoreAsync();
if (_session.Flow.Error is not ConnectError.None and var error && !_session.IsConnected) ErrorText = ServerSession.ErrorText(error);
}
public override void Dispose()
{
if (_session is not null) _session.PropertyChanged -= OnSessionChanged;
Sync.Dispose();
base.Dispose();
}
private void SetSyncOption(bool value, bool current, Action store, [System.Runtime.CompilerServices.CallerMemberName] string? name = null)
{
if (value == current) return;
store(value);
Shell.Services.SaveSettings();
Shell.Services.Sync.RequestRefresh();
OnPropertyChanged(name);
}
private async Task ConnectAsync()
{
ErrorText = null;
var connected = await Session.ConnectAsync(Address, Shell.Services.Dialogs);
if (connected)
{
Address = ServerAddress.Display(Session.SavedAddress);
return;
}
if (Session.Flow.Error is not ConnectError.None and var error) ErrorText = ServerSession.ErrorText(error);
}
private async Task SignOutAsync()
{
await Session.SignOutAsync();
ErrorText = null;
}
private void ShowCertificate()
{
if (Fingerprint is not { } fingerprint) return;
var forget = Shell.Services.Dialogs.Confirm(new ConfirmRequest
{
Heading = Loc.L("Server.Certificate.Title"),
Message = Loc.L("Server.Certificate.Message"),
Detail = ServerSession.FormatFingerprint(fingerprint),
DetailToolTip = Loc.L("Tooltips.Server.Fingerprint"),
SafeText = Loc.L("Server.Certificate.Keep"),
SafeToolTip = Loc.L("Tooltips.Server.KeepTrust"),
ActionText = Loc.L("Server.Certificate.Forget"),
ActionToolTip = Loc.L("Tooltips.Server.ForgetTrust"),
IsDestructive = true,
});
if (!forget) return;
Session.Disconnect();
Session.Forget(fingerprint);
}
private void OnSessionChanged(object? sender, PropertyChangedEventArgs e)
{
OnAllPropertiesChanged();
CommandManager.InvalidateRequerySuggested();
}
/// The name of a server role, or null for a role this build does not know.
private static string? KnownRole(string role) =>
Enum.TryParse(role, ignoreCase: true, out var parsed) ? parsed.ToString() : null;
}