using System.Collections.ObjectModel;
using Titano.App.Infrastructure;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Protocol;
using Titano.Ui.Mvvm;
namespace Titano.App.Server;
///
/// The client's server connection (BRIEF §12.7): drives with the dialogs (fingerprint
/// confirmation before any password is sent, login form), keeps the session token encrypted with DPAPI in the
/// settings, restores it at start, and lists servers announced on the LAN. Runs on the UI thread.
///
public sealed class ServerSession : ObservableObject, ITrustStore, IDisposable
{
private readonly AppSettings _settings;
private readonly Action _save;
private readonly ITokenProtector _protector;
private readonly ConnectFlow _flow;
private DiscoveryListener? _discovery;
private bool _busy;
public ServerSession(AppSettings settings, Action save, IServerApiFactory factory, ITokenProtector protector)
{
_settings = settings;
_save = save;
_protector = protector;
_flow = new ConnectFlow(factory, this);
_flow.Changed += (_, _) => OnAllPropertiesChanged();
}
public ConnectFlow Flow => _flow;
/// Servers that announced themselves on this network.
public ObservableCollection Discovered { get; } = [];
public bool IsConnected => _flow.Step == ConnectStep.Connected;
/// A connection attempt is running.
public bool IsBusy
{
get => _busy;
private set => Set(ref _busy, value);
}
/// Server name for the status strip; null when not connected.
public string? ServerName => IsConnected ? _flow.Info?.Name : null;
/// The saved address (last server used).
public string? SavedAddress => _settings.ServerUrl;
/// The token of the saved session is present (Disconnect keeps it).
public bool HasSavedSession => _settings.ServerUrl is not null && _settings.ProtectedToken is not null;
// ---------------- ITrustStore ----------------
public IReadOnlyCollection Fingerprints => [.. _settings.TrustedCertificates.Select(c => c.Fingerprint)];
public void Trust(string server, string fingerprint)
{
if (_settings.TrustedCertificates.Any(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase))) return;
_settings.TrustedCertificates.Add(new TrustedCertificate { Fingerprint = fingerprint, Server = server, TrustedAt = DateTimeOffset.UtcNow });
_save();
Log.Info("server", $"Trusted certificate {fingerprint} of {server}");
}
/// The trust record of a fingerprint, if the user trusted it.
public TrustedCertificate? TrustOf(string? fingerprint) =>
fingerprint is null ? null : _settings.TrustedCertificates.FirstOrDefault(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase));
/// Forgets a trusted certificate; the next connection asks again.
public void Forget(string fingerprint)
{
if (_settings.TrustedCertificates.RemoveAll(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase)) == 0) return;
_save();
OnAllPropertiesChanged();
}
///
/// Forgets a trusted certificate once the user confirmed it (Server screen and Settings › Server alike); the session
/// that relies on it is closed first. True when it was forgotten.
///
public bool ConfirmForget(string fingerprint, IAppDialogs dialogs)
{
if (!dialogs.Confirm(ForgetRequest(fingerprint))) return false;
if (IsConnected && string.Equals(TrustOf(_flow.Info?.TlsFingerprint)?.Fingerprint, fingerprint, StringComparison.OrdinalIgnoreCase)) Disconnect();
Forget(fingerprint);
return true;
}
// ---------------- Session ----------------
/// Resumes the saved session at start; stays signed out quietly when it cannot be reused.
public async Task RestoreAsync(CancellationToken ct = default)
{
if (_settings.ServerUrl is not { } address || _settings.ProtectedToken is not { } blob) return;
var token = _protector.Unprotect(blob);
if (token is null)
{
Log.Warning("server", "The saved session cannot be decrypted; sign in again");
ForgetToken();
return;
}
IsBusy = true;
try
{
var step = await _flow.RestoreAsync(address, token, ct);
if (step == ConnectStep.Connected) Log.Info("server", $"Session restored on {address}");
else if (_flow.Error is ConnectError.SessionExpired or ConnectError.CertificateChanged) ForgetToken();
}
finally
{
IsBusy = false;
}
}
///
/// Connects to : identifies the server, asks to trust an unknown self-signed
/// certificate, then reuses the saved session or shows the login form. True when connected.
///
public async Task ConnectAsync(string address, IAppDialogs dialogs, CancellationToken ct = default)
{
IsBusy = true;
try
{
var step = await _flow.ProbeAsync(address, ct);
if (step == ConnectStep.AwaitingTrust && _flow.PendingFingerprint is { } fingerprint)
{
var trusted = dialogs.Confirm(TrustRequest(ServerAddress.Display(_flow.Address!), fingerprint));
step = await _flow.ConfirmTrustAsync(trusted, ct);
}
if (step != ConnectStep.AwaitingCredentials) return false;
var display = ServerAddress.Display(_flow.Address!);
if (HasSavedSession && ServerAddress.Display(_settings.ServerUrl) == display && _protector.Unprotect(_settings.ProtectedToken!) is { } token)
{
step = await _flow.RestoreAsync(display, token, ct);
if (step == ConnectStep.Connected)
{
Remember();
return true;
}
if (step != ConnectStep.AwaitingCredentials) return false;
}
var signedIn = dialogs.SignIn(display, _settings.ServerUsername, async (user, password) =>
{
var result = await _flow.SignInAsync(user, password, ct);
return result == ConnectStep.Connected ? null : ErrorText(_flow.Error);
});
if (signedIn && IsConnected)
{
Remember();
return true;
}
if (!IsConnected && _flow.Step == ConnectStep.AwaitingCredentials) _flow.Disconnect();
return false;
}
finally
{
IsBusy = false;
}
}
/// Signs out on the server and removes the token from this PC.
public async Task SignOutAsync()
{
await _flow.SignOutAsync();
ForgetToken();
}
/// Closes the connection and works locally; the saved session is kept for the next Connect.
public void Disconnect() => _flow.Disconnect();
public void StartDiscovery()
{
if (_discovery is not null) return;
_discovery = new DiscoveryListener();
_discovery.Found += server =>
{
if (Discovered.Any(d => d.Address.Equals(server.Address, StringComparison.OrdinalIgnoreCase))) return;
Discovered.Add(server);
};
_discovery.Start();
}
public void Dispose()
{
_discovery?.Dispose();
_discovery = null;
_flow.Dispose();
}
/// One sentence for a failed step (BRIEF §0.2 rule 6).
public static string ErrorText(ConnectError error) => Loc.L("Server.Error." + error);
/// The trust-on-first-use question with the fingerprint split over two lines.
public static ConfirmRequest TrustRequest(string server, string fingerprint) => new()
{
Heading = Loc.L("Server.Trust.Title"),
Message = Loc.L("Server.Trust.Message", server),
Detail = FormatFingerprint(fingerprint),
DetailToolTip = Loc.L("Tooltips.Server.Fingerprint"),
SafeText = Loc.L("Server.Trust.Cancel"),
SafeToolTip = Loc.L("Tooltips.Server.DontTrust"),
ActionText = Loc.L("Server.Trust.Accept"),
ActionToolTip = Loc.L("Tooltips.Server.Trust"),
};
/// The destructive question before a trusted certificate is forgotten, with its fingerprint.
public static ConfirmRequest ForgetRequest(string fingerprint) => new()
{
Heading = Loc.L("Server.Certificate.Title"),
Message = Loc.L("Server.Certificate.Message"),
Detail = 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,
};
/// Splits the 32-byte SHA-256 fingerprint into two lines of 16 bytes, each kept left to right.
public static string FormatFingerprint(string fingerprint)
{
var bytes = fingerprint.Split(':');
return bytes.Length <= 16
? Formatting.LeftToRight(fingerprint)
: Formatting.LeftToRight(string.Join(':', bytes.Take(16))) + "\n" + Formatting.LeftToRight(string.Join(':', bytes.Skip(16)));
}
/// "9A:3C:71:E0:…" for the status line.
public static string ShortFingerprint(string fingerprint)
{
var bytes = fingerprint.Split(':');
return bytes.Length <= 4 ? fingerprint : string.Join(':', bytes.Take(4)) + ":…";
}
/// The account of the session (role, quota) for the Server screen.
public UserDto? User => IsConnected ? _flow.User : null;
private void Remember()
{
if (_flow.Address is null || _flow.Token is null) return;
var display = ServerAddress.Display(_flow.Address);
_settings.ServerUrl = display;
_settings.ServerUsername = _flow.User?.Username ?? _settings.ServerUsername;
_settings.ProtectedToken = _protector.Protect(_flow.Token);
_settings.RecentServers.RemoveAll(s => s.Equals(display, StringComparison.OrdinalIgnoreCase));
_settings.RecentServers.Insert(0, display);
if (_settings.RecentServers.Count > 8) _settings.RecentServers.RemoveRange(8, _settings.RecentServers.Count - 8);
_save();
Log.Info("server", $"Signed in to {display} as {_settings.ServerUsername}");
OnAllPropertiesChanged();
}
private void ForgetToken()
{
if (_settings.ProtectedToken is null) return;
_settings.ProtectedToken = null;
_save();
OnAllPropertiesChanged();
}
}