acdream/tests/AcDream.Launcher.Tests/LauncherWindowViewModelTests.cs

using AcDream.Launcher.Core.Orchestration;
using AcDream.Launcher.Core.Profiles;
using AcDream.Launcher.Core.Launching;
using AcDream.Launcher.Core.Installation;
using AcDream.Launcher.ViewModels;

namespace AcDream.Launcher.Tests;

public sealed class LauncherWindowViewModelTests
{
    [Fact]
    public void InitializeProjectsHierarchySessionsAndFutureWorkflowShells()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = new LauncherWindowViewModel(
            orchestrator,
            new ImmediateUiDispatcher());

        viewModel.Initialize();

        Assert.True(orchestrator.LoadCalled);
        LauncherTreeNodeViewModel server = Assert.Single(viewModel.Servers);
        Assert.Equal(LauncherTreeNodeKind.Server, server.Kind);
        LauncherTreeNodeViewModel account = Assert.Single(server.Children);
        Assert.Equal(LauncherTreeNodeKind.Account, account.Kind);
        LauncherTreeNodeViewModel character = Assert.Single(account.Children);
        Assert.Equal("+Acdream", character.DisplayName);
        Assert.Same(server, viewModel.SelectedNode);

        LauncherSessionRowViewModel session = Assert.Single(viewModel.Sessions);
        Assert.Equal("Gui", session.Mode);
        Assert.Equal("Connected", session.State);
        Assert.True(session.IsActive);

        Assert.True(viewModel.IsFirstRunRequired);
        Assert.Contains("SHA-256", viewModel.FirstRunWizardShell.Body, StringComparison.Ordinal);
        Assert.Contains("pinned eriknihlen/acdream", viewModel.UpdatePrompt.Body, StringComparison.Ordinal);
        viewModel.FirstRunWizardShell.OpenCommand.Execute(null);
        Assert.True(viewModel.FirstRunWizardShell.IsOpen);
        viewModel.FirstRunWizardShell.CloseCommand.Execute(null);
        Assert.False(viewModel.FirstRunWizardShell.IsOpen);
    }

    [Fact]
    public void ProfileCommandsExposeServerAccountCharacterCrudDialogsAndClearPasswords()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = CreateInitialized(orchestrator);

        viewModel.AddServerCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.AddServer, viewModel.EditorDialog.Kind);
        viewModel.EditorDialog.Name = "Remote ACE";
        viewModel.EditorDialog.Host = "ace.example.test";
        viewModel.EditorDialog.Port = "9001";
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(("Remote ACE", "ace.example.test", 9001), orchestrator.AddedServer);

        SelectServer(viewModel);
        viewModel.AddAccountCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.AddAccount, viewModel.EditorDialog.Kind);
        viewModel.EditorDialog.Name = "second-account";
        viewModel.EditorDialog.Password = "one-use-secret";
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(
            ("Local ACE", "second-account", "one-use-secret"),
            orchestrator.AddedAccount);
        Assert.Equal(string.Empty, viewModel.EditorDialog.Password);

        SelectAccount(viewModel);
        viewModel.AddCharacterCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.AddCharacter, viewModel.EditorDialog.Kind);
        viewModel.EditorDialog.Name = "+Second";
        viewModel.EditorDialog.CharacterId = "0x5000000B";
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(
            ("Local ACE", "testaccount", "+Second", "0x5000000B"),
            orchestrator.AddedCharacter);

        SelectCharacter(viewModel);
        viewModel.EditSelectedCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.EditCharacter, viewModel.EditorDialog.Kind);
        viewModel.EditorDialog.Name = "+Renamed";
        viewModel.EditorDialog.CharacterId = "0x5000000C";
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(
            ("Local ACE", "testaccount", "+Acdream", "+Renamed", "0x5000000C"),
            orchestrator.EditedCharacter);

        SelectCharacter(viewModel);
        viewModel.RemoveSelectedCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.Remove, viewModel.EditorDialog.Kind);
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(
            ("Local ACE", "testaccount", "+Acdream"),
            orchestrator.RemovedCharacter);
    }

    [Fact]
    public void ServerAndAccountEditRemoveDialogsRouteEveryMutationThroughCore()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = CreateInitialized(orchestrator);

        SelectServer(viewModel);
        viewModel.EditSelectedCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.EditServer, viewModel.EditorDialog.Kind);
        Assert.Equal("127.0.0.1", viewModel.EditorDialog.Host);
        viewModel.EditorDialog.Name = "Renamed ACE";
        viewModel.EditorDialog.Host = "renamed.example.test";
        viewModel.EditorDialog.Port = "9010";
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(
            ("Local ACE", "Renamed ACE", "renamed.example.test", 9010),
            orchestrator.EditedServer);

        SelectAccount(viewModel);
        viewModel.EditSelectedCommand.Execute(null);
        Assert.Equal(ProfileEditorKind.EditAccount, viewModel.EditorDialog.Kind);
        viewModel.EditorDialog.Name = "renamed-account";
        viewModel.EditorDialog.Password = "replacement-secret";
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(
            ("Local ACE", "testaccount", "renamed-account", "replacement-secret"),
            orchestrator.EditedAccount);
        Assert.Equal(string.Empty, viewModel.EditorDialog.Password);

        SelectAccount(viewModel);
        viewModel.RemoveSelectedCommand.Execute(null);
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal(("Local ACE", "testaccount"), orchestrator.RemovedAccount);

        SelectServer(viewModel);
        viewModel.RemoveSelectedCommand.Execute(null);
        viewModel.EditorDialog.SubmitCommand.Execute(null);
        Assert.Equal("Local ACE", orchestrator.RemovedServer);
    }

    [Fact]
    public async Task CharacterSettingsAndLaunchActionsPreserveTheirTypedSemantics()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = CreateInitialized(orchestrator);
        SelectCharacter(viewModel);

        viewModel.CharacterLaunchMode = LaunchMode.Headless;
        viewModel.CharacterPluginsText = "Plugin.One\nPlugin.Two\nPlugin.One";
        viewModel.CharacterLoginCommandsText = " /tell someone, hi \n/vt start\n/tell someone, hi";
        viewModel.SaveCharacterSettingsCommand.Execute(null);

        Assert.NotNull(orchestrator.SettingsUpdate);
        Assert.Equal(LaunchMode.Headless, orchestrator.SettingsUpdate.Value.Mode);
        Assert.Equal(["Plugin.One", "Plugin.Two"], orchestrator.SettingsUpdate.Value.Plugins);
        Assert.Equal(
            ["/tell someone, hi", "/vt start", "/tell someone, hi"],
            orchestrator.SettingsUpdate.Value.Commands);

        await viewModel.LaunchHeadlessCommand.ExecuteAsync();
        Assert.Equal(
            ("Local ACE", "testaccount", "+Acdream", LaunchMode.Headless),
            orchestrator.LaunchRequest);
        Assert.Equal("Headless session started for +Acdream.", viewModel.OperationStatus);
    }

    [Fact]
    public async Task AccountGuiSelectWorksWithoutAnyCachedCharacter()
    {
        using var orchestrator = new FakeLauncherOrchestrator
        {
            IncludeCharacter = false,
        };
        using var viewModel = CreateInitialized(orchestrator);
        SelectAccount(viewModel);

        Assert.Empty(viewModel.SelectedNode!.Children);
        Assert.True(viewModel.CanLaunchAccountGuiSelect);
        await viewModel.LaunchAccountGuiSelectCommand.ExecuteAsync();

        Assert.Equal(
            ("Local ACE", "testaccount", (string?)null, LaunchMode.GuiSelect),
            orchestrator.LaunchRequest);
        Assert.Equal(
            "Character-select session started for testaccount.",
            viewModel.OperationStatus);
    }

    [Fact]
    public async Task ProbeUsesTheSelectedAccountAndRunningAccountDisablesIt()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = CreateInitialized(orchestrator);
        SelectAccount(viewModel);

        Assert.True(viewModel.CanProbe);
        await viewModel.RefreshCharactersCommand.ExecuteAsync();
        Assert.Equal(("Local ACE", "testaccount"), orchestrator.ProbeRequest);

        orchestrator.ProbeCapability = LauncherCapability.Unavailable(
            "Stop the active session before refreshing this account.");
        orchestrator.RaiseStateChanged();

        SelectAccount(viewModel);
        Assert.False(viewModel.CanProbe);
        Assert.Contains("Stop", viewModel.ProbeDisabledReason, StringComparison.Ordinal);
    }

    [Fact]
    public void LinuxKeepsLauncherAndHeadlessAvailableButExplainsDisabledGuiModes()
    {
        using var orchestrator = new FakeLauncherOrchestrator
        {
            Platform = LinuxPlatform(),
        };
        using var viewModel = CreateInitialized(orchestrator);
        SelectCharacter(viewModel);

        Assert.True(viewModel.ShowLinuxGraphicalNotice);
        Assert.False(viewModel.CanLaunchGui);
        Assert.False(viewModel.CanLaunchGuiSelect);
        Assert.True(viewModel.CanLaunchHeadless);
        Assert.Equal(
            LauncherPlatformCapabilities.LinuxGraphicalLaunchDisabledReason,
            viewModel.LinuxGraphicalNotice);
        Assert.Contains("Slice L", viewModel.GuiLaunchDisabledReason, StringComparison.Ordinal);
        Assert.Contains("parked at L1", viewModel.GuiLaunchDisabledReason, StringComparison.Ordinal);
    }

    [Fact]
    public void MissingCoDeployedHostReasonIsVisibleForCharacterActions()
    {
        using var orchestrator = new FakeLauncherOrchestrator
        {
            AccountLaunchCapability = LauncherCapability.Unavailable(
                "The co-deployed host is missing; reinstall or update the client."),
        };
        using var viewModel = CreateInitialized(orchestrator);
        SelectCharacter(viewModel);

        Assert.False(viewModel.CanLaunchGui);
        Assert.False(viewModel.CanLaunchHeadless);
        Assert.True(viewModel.ShowGuiLaunchDisabledReason);
        Assert.True(viewModel.ShowHeadlessLaunchDisabledReason);
        Assert.Contains("missing", viewModel.GuiLaunchDisabledReason, StringComparison.Ordinal);
        Assert.Contains("missing", viewModel.HeadlessLaunchDisabledReason, StringComparison.Ordinal);
    }

    [Fact]
    public async Task LaunchErrorAndCancellationBecomeSafeVisibleState()
    {
        using var orchestrator = new FakeLauncherOrchestrator
        {
            LaunchHandler = _ => throw new LauncherOperationException("spawn failed safely"),
        };
        using var viewModel = CreateInitialized(orchestrator);
        SelectCharacter(viewModel);

        await viewModel.LaunchGuiCommand.ExecuteAsync();

        Assert.Equal("spawn failed safely", viewModel.LastError);
        Assert.Equal("Operation failed.", viewModel.OperationStatus);
        Assert.False(viewModel.IsBusy);

        orchestrator.LaunchHandler = async cancellationToken =>
        {
            await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken);
            return FakeLauncherOrchestrator.CreateSession();
        };
        Task launch = viewModel.LaunchGuiCommand.ExecuteAsync();
        Assert.True(viewModel.IsBusy);
        Assert.True(viewModel.CancelOperationCommand.CanExecute(null));
        viewModel.CancelOperationCommand.Execute(null);
        await launch;

        Assert.Equal("Operation cancelled.", viewModel.OperationStatus);
        Assert.False(viewModel.HasError);
        Assert.False(viewModel.IsBusy);
    }

    [Fact]
    public void ProfileDialogRedactsARejectedCredentialAndClearsItOnClose()
    {
        var dialog = new ProfileEditorDialogViewModel();
        dialog.Open(
            ProfileEditorKind.AddAccount,
            "Add account",
            candidate => throw new InvalidOperationException(
                $"rejected {candidate.Password}"));
        dialog.Password = "do-not-display";

        dialog.SubmitCommand.Execute(null);

        Assert.True(dialog.IsOpen);
        Assert.DoesNotContain("do-not-display", dialog.Error ?? string.Empty, StringComparison.Ordinal);
        Assert.Contains("[redacted]", dialog.Error ?? string.Empty, StringComparison.Ordinal);
        dialog.CancelCommand.Execute(null);
        Assert.Equal(string.Empty, dialog.Password);
        Assert.False(dialog.IsOpen);
    }

    [Fact]
    public void ModalShellsBlockBackgroundCommandsAndAreMutuallyExclusive()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = CreateInitialized(orchestrator);

        Assert.True(viewModel.AddServerCommand.CanExecute(null));
        viewModel.FirstRunWizardShell.OpenCommand.Execute(null);
        Assert.True(viewModel.IsModalOpen);
        Assert.False(viewModel.AddServerCommand.CanExecute(null));
        Assert.False(viewModel.UpdatePrompt.OpenCommand.CanExecute(null));
        Assert.False(Assert.Single(viewModel.Sessions).StopCommand.CanExecute(null));

        // ICommand.Execute cannot bypass the modal gate.
        viewModel.AddServerCommand.Execute(null);
        Assert.False(viewModel.EditorDialog.IsOpen);
        Assert.Null(orchestrator.AddedServer);

        viewModel.CloseActiveModal();
        Assert.False(viewModel.IsModalOpen);
        Assert.True(viewModel.AddServerCommand.CanExecute(null));

        viewModel.AddServerCommand.Execute(null);
        Assert.True(viewModel.EditorDialog.IsOpen);
        Assert.False(viewModel.FirstRunWizardShell.OpenCommand.CanExecute(null));
        Assert.False(viewModel.ClearFinishedSessionsCommand.CanExecute(null));
        viewModel.CloseActiveModal();
        Assert.False(viewModel.EditorDialog.IsOpen);
    }

    [Fact]
    public async Task FirstRunWizardAutoDetectsValidatesAndPublishesVerifiedInstall()
    {
        using var orchestrator = new FakeLauncherOrchestrator
        {
            Session = FakeLauncherOrchestrator.CreateSession(
                LauncherActivityState.Exited,
                "Exited cleanly."),
        };
        var installer = new FakeLauncherInstaller();
        using var viewModel = CreateInitialized(orchestrator, installer);

        viewModel.FirstRunWizardShell.OpenCommand.Execute(null);

        Assert.Equal(installer.DetectedDirectory, viewModel.FirstRunWizardShell.DatDirectory);
        Assert.True(viewModel.FirstRunWizardShell.IsDatDirectoryValid);
        Assert.True(viewModel.FirstRunWizardShell.StartCommand.CanExecute(null));

        viewModel.FirstRunWizardShell.SelectDatDirectory("incomplete-manual-path");
        Assert.False(viewModel.FirstRunWizardShell.IsDatDirectoryValid);
        viewModel.FirstRunWizardShell.SelectDatDirectory(installer.DetectedDirectory);
        Assert.True(viewModel.FirstRunWizardShell.IsDatDirectoryValid);

        viewModel.FirstRunWizardShell.ThreadsText = "3";
        await viewModel.FirstRunWizardShell.StartCommand.ExecuteAsync();

        Assert.Equal((installer.DetectedDirectory, 3), installer.InstallRequest);
        Assert.Equal(installer.Record, orchestrator.InstalledRecord);
        Assert.False(viewModel.IsFirstRunRequired);
        Assert.Equal(LauncherInstallPhase.Completed, viewModel.FirstRunWizardShell.Phase);
        Assert.Equal(100, viewModel.FirstRunWizardShell.ProgressPercent);
        Assert.False(viewModel.FirstRunWizardShell.HasError);
    }

    [Fact]
    public async Task FirstRunWizardCancellationAndFailureRemainVisibleAndPublishNothing()
    {
        using var orchestrator = new FakeLauncherOrchestrator
        {
            Session = FakeLauncherOrchestrator.CreateSession(
                LauncherActivityState.Exited,
                "Exited cleanly."),
        };
        var entered = new TaskCompletionSource(
            TaskCreationOptions.RunContinuationsAsynchronously);
        var installer = new FakeLauncherInstaller
        {
            InstallHandler = async (_, _, progress, cancellationToken) =>
            {
                progress?.Report(new LauncherInstallProgress(
                    LauncherInstallPhase.BakingMeshes,
                    "Baking mesh assets.",
                    1,
                    10));
                entered.SetResult();
                await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken);
                throw new InvalidOperationException("unreachable");
            },
        };
        using var viewModel = CreateInitialized(orchestrator, installer);
        viewModel.FirstRunWizardShell.OpenCommand.Execute(null);

        Task install = viewModel.FirstRunWizardShell.StartCommand.ExecuteAsync();
        await entered.Task.WaitAsync(
            TimeSpan.FromSeconds(5),
            TestContext.Current.CancellationToken);
        Assert.True(viewModel.FirstRunWizardShell.CancelCommand.CanExecute(null));
        Assert.False(viewModel.FirstRunWizardShell.CanEditInputs);
        viewModel.FirstRunWizardShell.CancelCommand.Execute(null);
        await install;

        Assert.Equal(LauncherInstallPhase.Cancelled, viewModel.FirstRunWizardShell.Phase);
        Assert.Null(orchestrator.InstalledRecord);
        Assert.False(viewModel.FirstRunWizardShell.HasError);

        installer.InstallHandler = (_, _, _, _) =>
            Task.FromException<LauncherInstallResult>(
                new LauncherInstallException("fixture bake failed"));
        await viewModel.FirstRunWizardShell.StartCommand.ExecuteAsync();

        Assert.Equal(LauncherInstallPhase.Failed, viewModel.FirstRunWizardShell.Phase);
        Assert.Contains(
            "fixture bake failed",
            viewModel.FirstRunWizardShell.Error ?? string.Empty,
            StringComparison.Ordinal);
        Assert.Null(orchestrator.InstalledRecord);
    }

    [Fact]
    public async Task ActiveSessionStopAndFinishedSessionClearUseCoreOwnership()
    {
        using var orchestrator = new FakeLauncherOrchestrator();
        using var viewModel = CreateInitialized(orchestrator);

        LauncherSessionRowViewModel session = Assert.Single(viewModel.Sessions);
        await session.StopCommand.ExecuteAsync();
        Assert.Equal("session-1", orchestrator.StoppedSessionId);

        orchestrator.Session = FakeLauncherOrchestrator.CreateSession(
            LauncherActivityState.Exited,
            "Exited cleanly.");
        orchestrator.RaiseStateChanged();
        Assert.True(viewModel.ClearFinishedSessionsCommand.CanExecute(null));
        viewModel.ClearFinishedSessionsCommand.Execute(null);
        Assert.True(orchestrator.ClearCalled);
    }

    private static LauncherWindowViewModel CreateInitialized(
        FakeLauncherOrchestrator orchestrator,
        ILauncherInstaller? installer = null)
    {
        var viewModel = new LauncherWindowViewModel(
            orchestrator,
            new ImmediateUiDispatcher(),
            installer);
        viewModel.Initialize();
        return viewModel;
    }

    private static void SelectServer(LauncherWindowViewModel viewModel) =>
        viewModel.SelectedNode = Assert.Single(viewModel.Servers);

    private static void SelectAccount(LauncherWindowViewModel viewModel) =>
        viewModel.SelectedNode = Assert.Single(Assert.Single(viewModel.Servers).Children);

    private static void SelectCharacter(LauncherWindowViewModel viewModel) =>
        viewModel.SelectedNode = Assert.Single(
            Assert.Single(Assert.Single(viewModel.Servers).Children).Children);

    private static LauncherPlatformCapabilities LinuxPlatform() => new(
        IsWindows: false,
        IsLinux: true,
        CanRunHeadless: true,
        CanLaunchGraphicalClient: false,
        PlatformName: "Linux",
        GraphicalLaunchDisabledReason:
            LauncherPlatformCapabilities.LinuxGraphicalLaunchDisabledReason);

    private sealed class FakeLauncherOrchestrator : ILauncherOrchestrator
    {
        public event EventHandler? StateChanged;

        public bool LoadCalled { get; private set; }

        public bool ClearCalled { get; private set; }

        public LauncherPlatformCapabilities Platform { get; init; } = new(
            IsWindows: true,
            IsLinux: false,
            CanRunHeadless: true,
            CanLaunchGraphicalClient: true,
            PlatformName: "Windows",
            GraphicalLaunchDisabledReason: null);

        public LauncherCapability ProbeCapability { get; set; } = LauncherCapability.Available;

        public LauncherCapability? AccountLaunchCapability { get; set; }

        public bool IncludeCharacter { get; init; } = true;

        public LauncherSessionSnapshot Session { get; set; } = CreateSession();

        public Func<CancellationToken, Task<LauncherSessionSnapshot>>? LaunchHandler { get; set; }

        public (string Name, string Host, int Port)? AddedServer { get; private set; }

        public (string Name, string NewName, string NewHost, int NewPort)? EditedServer { get; private set; }

        public string? RemovedServer { get; private set; }

        public (string Server, string Account, string Password)? AddedAccount { get; private set; }

        public (string Server, string Account, string NewAccount, string? Password)? EditedAccount { get; private set; }

        public (string Server, string Account)? RemovedAccount { get; private set; }

        public (string Server, string Account, string Character, string? Id)? AddedCharacter { get; private set; }

        public (string Server, string Account, string Character, string NewName, string? Id)? EditedCharacter { get; private set; }

        public (string Server, string Account, string Character)? RemovedCharacter { get; private set; }

        public (LaunchMode Mode, IReadOnlyList<string> Plugins, IReadOnlyList<string> Commands)? SettingsUpdate { get; private set; }

        public (string Server, string Account, string? Character, LaunchMode Mode)? LaunchRequest { get; private set; }

        public (string Server, string Account)? ProbeRequest { get; private set; }

        public string? StoppedSessionId { get; private set; }

        public LauncherInstallRecord? InstalledRecord { get; private set; }

        public void LoadProfiles() => LoadCalled = true;

        public LauncherStateSnapshot GetSnapshot() => new(
            [CreateServerSnapshot()],
            [Session],
            Platform,
            IsInstallationReady: InstalledRecord is not null,
            InstallationStatus: InstalledRecord is null
                ? "No installed client is configured."
                : "Client content verified.");

        public LauncherCapability GetLaunchCapability(LaunchMode mode) =>
            Platform.ForLaunchMode(mode);

        public LauncherCapability GetAccountLaunchCapability(
            string serverName,
            string accountName,
            LaunchMode mode) =>
            AccountLaunchCapability ?? GetLaunchCapability(mode);

        public LauncherCapability GetProbeCapability(string serverName, string accountName) =>
            ProbeCapability;

        public void SetInstallRecord(LauncherInstallRecord? installRecord)
        {
            InstalledRecord = installRecord;
            StateChanged?.Invoke(this, EventArgs.Empty);
        }

        public void AddServer(string name, string host, int port) =>
            AddedServer = (name, host, port);

        public void EditServer(string name, string newName, string newHost, int newPort) =>
            EditedServer = (name, newName, newHost, newPort);

        public void RemoveServer(string name) => RemovedServer = name;

        public void AddAccount(string serverName, string accountName, string password) =>
            AddedAccount = (serverName, accountName, password);

        public void EditAccount(
            string serverName,
            string accountName,
            string newAccountName,
            string? newPassword) =>
            EditedAccount = (serverName, accountName, newAccountName, newPassword);

        public void RemoveAccount(string serverName, string accountName) =>
            RemovedAccount = (serverName, accountName);

        public void AddCharacter(
            string serverName,
            string accountName,
            string characterName,
            string? characterId) =>
            AddedCharacter = (serverName, accountName, characterName, characterId);

        public void EditCharacterIdentity(
            string serverName,
            string accountName,
            string characterName,
            string newCharacterName,
            string? newCharacterId) =>
            EditedCharacter = (
                serverName,
                accountName,
                characterName,
                newCharacterName,
                newCharacterId);

        public void UpdateCharacterSettings(
            string serverName,
            string accountName,
            string characterName,
            LaunchMode launchMode,
            IReadOnlyList<string> plugins,
            IReadOnlyList<string> loginCommands) =>
            SettingsUpdate = (launchMode, plugins, loginCommands);

        public void RemoveCharacter(
            string serverName,
            string accountName,
            string characterName) =>
            RemovedCharacter = (serverName, accountName, characterName);

        public Task<LauncherSessionSnapshot> LaunchAsync(
            string serverName,
            string accountName,
            string? characterName,
            LaunchMode mode,
            CancellationToken cancellationToken = default)
        {
            LaunchRequest = (serverName, accountName, characterName, mode);
            return LaunchHandler?.Invoke(cancellationToken) ?? Task.FromResult(Session);
        }

        public Task<LauncherSessionSnapshot> ProbeAsync(
            string serverName,
            string accountName,
            CancellationToken cancellationToken = default)
        {
            ProbeRequest = (serverName, accountName);
            return Task.FromResult(Session with { Kind = LauncherActivityKind.Probe });
        }

        public Task StopSessionAsync(
            string sessionId,
            TimeSpan timeout,
            CancellationToken cancellationToken = default)
        {
            StoppedSessionId = sessionId;
            return Task.CompletedTask;
        }

        public void PollStatus()
        {
        }

        public void ClearFinishedSessions() => ClearCalled = true;

        public void Dispose()
        {
        }

        public void RaiseStateChanged() => StateChanged?.Invoke(this, EventArgs.Empty);

        public static LauncherSessionSnapshot CreateSession(
            LauncherActivityState state = LauncherActivityState.Connected,
            string status = "Connected.") => new(
                "session-1",
                LauncherActivityKind.Play,
                "Local ACE",
                "testaccount",
                "+Acdream",
                LaunchMode.Gui,
                state,
                status,
                ExitCode: state == LauncherActivityState.Exited ? 0 : null,
                Error: null,
                CreatedAt: DateTimeOffset.UnixEpoch);

        private LauncherServerSnapshot CreateServerSnapshot() => new(
            "Local ACE",
            "127.0.0.1",
            9000,
            [
                new LauncherAccountSnapshot(
                    "Local ACE",
                    "testaccount",
                    IncludeCharacter
                        ?
                        [
                            new LauncherCharacterSnapshot(
                                "Local ACE",
                                "testaccount",
                                "+Acdream",
                                "0x5000000A",
                                LaunchMode.GuiSelect,
                                ["Existing.Plugin"],
                                ["/tell someone, ready"],
                                HasRunningSession: true,
                                SessionStatus: "Connected."),
                        ]
                        : [],
                    HasRunningActivity: true,
                    ActivityStatus: "Connected."),
            ]);
    }

    private sealed class FakeLauncherInstaller : ILauncherInstaller
    {
        public string DetectedDirectory { get; } = Path.GetFullPath("retail-dats");

        public LauncherInstallRecord Record { get; }

        public (string DatDirectory, int Threads)? InstallRequest { get; private set; }

        public Func<
            string,
            int,
            IProgress<LauncherInstallProgress>?,
            CancellationToken,
            Task<LauncherInstallResult>>? InstallHandler { get; set; }

        public FakeLauncherInstaller()
        {
            Record = new LauncherInstallRecord(
                DetectedDirectory,
                Path.GetFullPath("data/pak/acdream.pak"),
                new string('a', 64),
                123,
                LauncherInstallRecordStore.CurrentBakeToolVersion);
        }

        public IReadOnlyList<DatDirectoryValidation> DetectDatDirectories() =>
        [
            ValidateDatDirectory(DetectedDirectory),
        ];

        public DatDirectoryValidation ValidateDatDirectory(string? directory) =>
            string.Equals(directory, DetectedDirectory, StringComparison.Ordinal)
                ? new DatDirectoryValidation(
                    DetectedDirectory,
                    true,
                    "All four required retail DAT files were found.",
                    [])
                : new DatDirectoryValidation(
                    directory ?? string.Empty,
                    false,
                    "The DAT directory is incomplete.",
                    DatDirectoryLocator.RequiredFileNames);

        public Task<InstallRecordVerification> LoadExistingAsync(
            CancellationToken cancellationToken = default) =>
            Task.FromResult(new InstallRecordVerification(
                InstallRecordVerificationState.Missing,
                null,
                "Client content is not installed."));

        public Task<LauncherInstallResult> InstallAsync(
            string datDirectory,
            int threads,
            IProgress<LauncherInstallProgress>? progress = null,
            CancellationToken cancellationToken = default)
        {
            cancellationToken.ThrowIfCancellationRequested();
            InstallRequest = (datDirectory, threads);
            if (InstallHandler is not null)
            {
                return InstallHandler(
                    datDirectory,
                    threads,
                    progress,
                    cancellationToken);
            }

            progress?.Report(new LauncherInstallProgress(
                LauncherInstallPhase.BakingMeshes,
                "Baking mesh assets.",
                5,
                10));
            progress?.Report(new LauncherInstallProgress(
                LauncherInstallPhase.VerifyingPackage,
                "Verifying package."));
            return Task.FromResult(new LauncherInstallResult(Record));
        }
    }
}