using Avalonia.Controls;
using Avalonia.VisualTree;
using DodoSSH.Client.App.ViewModels;
using DodoSSH.Client.App.Views;
using DodoSSH.Client.Session;
using DodoSSH.Client.Session.Tests;
using DodoSSH.Client.Ssh;
using DodoSSH.Client.Storage;
using DodoSSH.Client.Terminal;
using DodoSSH.Crypto;
using NSubstitute;

namespace DodoSSH.Client.App.Layout.Tests;

/// <summary>
/// Whether each screen fits in the space the window gives it.
/// </summary>
/// <remarks>
/// <para>
/// This suite used to measure one control, <c>VaultColumn</c>, because there was one. The design import
/// split it in two — the host list lives beside the terminal, and everything else in the vault has a screen
/// of its own — and added a titlebar, a nav rail and a status bar. That is five things to measure, and the
/// split is what keeps every one of them measurable: none contains the terminal's WebView, and
/// <c>MainWindow</c> still cannot be laid out here at all, because WebView2's adapter refuses the headless
/// dispatcher's MTA thread. <see cref="LayoutHarnessTests"/> pins that.
/// </para>
/// <para>
/// One test per shape a user can put a screen into, because a shape that is never laid out is a shape never
/// checked. The host sidebar has three — list, list with the editor open, and list folded away — and the
/// vault screen has one per category plus one per editor.
/// </para>
/// <para>
/// A real <c>VaultViewModel</c> over a real unlocked vault, rather than a stand-in. Compiled bindings
/// resolve against the declared data type, so a stand-in would have to be the same type anyway — and the
/// editors' height depends on real content: a key with a real armour block in the box is taller than an
/// empty one.
/// </para>
/// </remarks>
public sealed class ScreenLayoutTests : IAsyncLifetime
{
    private const string Passphrase = "a sufficiently long passphrase";
    private const string ServerUrl = "https://dodossh.example";

    /// <remarks>Far below the shipped profile: nothing here attacks a wrap.</remarks>
    private static readonly Argon2Profile CheapProfile =
        Argon2Profile.FromStoredParameters(memoryKibibytes: 8 * 1024, passes: 1, parallelism: 1);

    private readonly FakeAccountServer server = new();
    private readonly StubKeyBinding keyBinding = new();
    private readonly VaultKnownHostStore knownHosts = new();

    private ClientCacheFactory caches = null!;
    private TerminalWorkspace workspace = null!;
    private VaultSession session = null!;
    private VaultViewModel vault = null!;

    private static CancellationToken Token => TestContext.Current.CancellationToken;

    /// <inheritdoc />
    public async ValueTask InitializeAsync()
    {
        caches = ClientCacheFactory.ForMemory($"layout-{Guid.CreateVersion7():N}");
        await caches.MigrateAsync(Token);

        await new AccountProvisioner(server, keyBinding, caches, TimeProvider.System, CheapProfile)
            .EnrollAsync(ServerUrl, Passphrase, "laptop", "Personal", Token);

        var outcome = await new SessionOpener(caches, TimeProvider.System).UnlockAsync(Passphrase, Token);
        outcome.IsUnlocked.ShouldBeTrue(outcome.Message);
        session = outcome.Session!;

        // Never started and never connected through: no screen's layout depends on the terminal, and the
        // substitute is here only because the view model's constructor asks for one.
        workspace = new TerminalWorkspace(
            new InMemoryTerminalAssetProvider(new Dictionary<string, TerminalAsset>(StringComparer.Ordinal)),
            Substitute.For<ISshConnectionFactory>(),
            TimeProvider.System);

        await knownHosts.OpenAsync(session, Token);

        // Offline. A null connection is what these screens show on a laptop with no network, and it keeps
        // every sync pass out of a suite that is only measuring rectangles.
        vault = new VaultViewModel(session, workspace, knownHosts, static () => null);

        await SeedAsync();
    }

    /// <inheritdoc />
    public async ValueTask DisposeAsync()
    {
        await vault.DisposeAsync();
        knownHosts.Close();
        await workspace.DisposeAsync();
        await session.DisposeAsync();
        caches.Dispose();
    }

    // ---- The host sidebar ----

    [Fact]
    public async Task TheHostSidebarFitsWithNoEditorOpen()
    {
        await MeasureSidebarAsync(faults => faults.ShouldBeEmpty());
    }

    /// <remarks>
    /// The tight one, and the reason this suite still exists. The sidebar is 268 pixels wide against the old
    /// column's 340, and the host editor is the tallest thing in it: six fields, an authentication picker
    /// with a two-line item template, a checkbox, a paragraph of hint text and three buttons, all sharing a
    /// column with the list above them.
    /// </remarks>
    [Fact]
    public async Task TheHostSidebarFitsWithItsEditorOpen()
    {
        vault.SelectedHost = vault.Hosts[0];
        vault.EditSelectedHostCommand.Execute(null);

        vault.EditorAuthenticationChoices.Count
            .ShouldBeGreaterThan(1, "the picker has to be populated for this to measure anything");

        // Measured with a credential selected, because an empty picker is shorter than one showing a
        // qualifier beside a label.
        vault.EditorSelectedAuthentication = vault.EditorAuthenticationChoices
            .First(choice => choice.Kind is AuthenticationKind.Credential);

        await MeasureSidebarAsync(faults => faults.ShouldBeEmpty());
    }

    /// <remarks>
    /// Folding the list away is the one thing a user can do to this control that changes which of its parts
    /// is on screen, so it is a shape worth laying out on its own.
    /// </remarks>
    [Fact]
    public async Task TheHostSidebarFitsWithItsListFoldedAway()
    {
        vault.ToggleHostsCommand.Execute(null);
        vault.AreHostsExpanded.ShouldBeFalse();

        await MeasureSidebarAsync(faults => faults.ShouldBeEmpty());
    }

    /// <remarks>
    /// <para>
    /// The one thing a wrong answer here breaks is unrecoverable from the keyboard: <c>MainWindow</c> takes
    /// the keyboard off the terminal's native child window first and then focuses this target, so a target
    /// that cannot take focus leaves the user with no focused element and no way back except the mouse.
    /// </para>
    /// <para>
    /// Which is why this asserts that focus was <i>taken</i> rather than that the right control was named.
    /// A <c>ListBox</c> is not focusable by default, so the call returns false against a list that has not
    /// asked to be — and <c>Focus()</c> on a collapsed control is a no-op that is not replayed when it is
    /// revealed, which is exactly what the folded-away case would hit.
    /// </para>
    /// </remarks>
    [Fact]
    public async Task TheSidebarsKeyboardTargetTakesFocusInBothOfItsShapes()
    {
        await OnTheSidebarAsync((sidebar, _) =>
        {
            sidebar.KeyboardTarget.ShouldBeSameAs(sidebar.HostList);
            sidebar.KeyboardTarget.Focus().ShouldBeTrue("the list is showing");
        });

        vault.ToggleHostsCommand.Execute(null);

        await OnTheSidebarAsync((sidebar, _) =>
        {
            sidebar.KeyboardTarget.ShouldBeSameAs(sidebar.HostFilter);
            sidebar.KeyboardTarget.Focus().ShouldBeTrue("the list is folded away, so the filter takes it");
        });
    }

    /// <remarks>
    /// The editor open with the list still on screen behind it, which is the state a user is most likely to
    /// leave the sidebar in — so it is the state the keyboard answer most has to hold in.
    /// </remarks>
    [Fact]
    public async Task TheSidebarsKeyboardTargetStillTakesFocusWithTheEditorOpen()
    {
        vault.NewHostCommand.Execute(null);

        await OnTheSidebarAsync((sidebar, _) =>
        {
            sidebar.HostList.IsEffectivelyVisible.ShouldBeTrue();
            sidebar.KeyboardTarget.Focus().ShouldBeTrue();
        });
    }

    // ---- The vault screen ----

    [Fact]
    public async Task TheVaultScreenFitsInEveryCategory()
    {
        foreach (var section in new[]
        {
            VaultSection.All, VaultSection.Keys, VaultSection.Credentials, VaultSection.KnownHosts,
        })
        {
            vault.Section = section;

            await MeasureVaultAsync(faults => faults.ShouldBeEmpty($"the {section} category"));
        }
    }

    /// <remarks>
    /// The tall one: a private key needs a real text area, and the vault screen's detail pane is 244 pixels
    /// wide — the narrowest column any form in this application has to fit into.
    /// </remarks>
    [Fact]
    public async Task TheVaultScreenFitsWithTheKeyEditorOpen()
    {
        vault.NewKeyCommand.Execute(null);
        vault.IsEditingKey.ShouldBeTrue();
        vault.ShowsKeys.ShouldBeTrue("opening an editor has to bring its own category into view");

        vault.KeyEditorPrivateKey = string.Join(
            '\n',
            Enumerable.Repeat("b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gt", 6));

        await MeasureVaultAsync(faults => faults.ShouldBeEmpty());
    }

    [Fact]
    public async Task TheVaultScreenFitsWithThePasswordEditorOpen()
    {
        vault.NewCredentialCommand.Execute(null);
        vault.IsEditingCredential.ShouldBeTrue();
        vault.ShowsCredentials.ShouldBeTrue("opening an editor has to bring its own category into view");

        await MeasureVaultAsync(faults => faults.ShouldBeEmpty());
    }

    /// <remarks>
    /// The detail pane with something selected, which is what the design's right-hand column is really about
    /// — and the pin is the one carrying a full fingerprint on a wrapped monospace line.
    /// </remarks>
    [Fact]
    public async Task TheVaultScreenFitsWithAPinSelected()
    {
        vault.Section = VaultSection.KnownHosts;
        vault.VaultItems.ShouldNotBeEmpty("an empty list is the easy case and proves nothing here");

        vault.SelectedVaultItem = vault.VaultItems[0];
        vault.SelectedItemIsPin.ShouldBeTrue();

        await MeasureVaultAsync(faults => faults.ShouldBeEmpty());
    }

    /// <remarks>
    /// The rail is the only way to reach a category, so a button that lands on nothing walls off three
    /// quarters of the screen. The fit tests above prove the buttons are inside the window; this proves they
    /// are the size a pointer can find, which a zero-height row in a collapsed border would not be.
    /// </remarks>
    [Fact]
    public async Task TheCategoryRailIsBigEnoughToClick()
    {
        await OnTheVaultAsync((screen, _) =>
        {
            var buttons = screen.GetVisualDescendants()
                .OfType<Button>()
                .Where(button => button.Classes.Contains("cat"))
                .ToList();

            buttons.Count.ShouldBe(4, "one per category that exists");

            foreach (var button in buttons)
            {
                button.Bounds.Height.ShouldBeGreaterThan(20);
                button.Bounds.Width.ShouldBeGreaterThan(120);
            }
        });
    }

    // ---- The chrome ----

    /// <remarks>
    /// <para>
    /// The two constants the whole height budget is subtracted from, held against the markup that declares
    /// them. If either bar grows, every screen gets less room than this suite thinks it does and every
    /// measurement above quietly becomes optimistic.
    /// </para>
    /// <para>
    /// Laid out with no data context, which is the point: these are fixed-height strips and their geometry
    /// must not depend on what is bound into them. A binding that made one of them grow with its contents
    /// would fail here.
    /// </para>
    /// </remarks>
    [Fact]
    public async Task TheChromeIsTheHeightTheBudgetAssumes()
    {
        await LayoutHarness.OnTheUiThreadAsync(
            () =>
            {
                var titleBar = new TitleBar();
                var titleWindow = LayoutHarness.HostAtMinimumSize(
                    titleBar, LayoutHarness.MinimumWidth, LayoutHarness.TitleBarHeight);

                try
                {
                    titleBar.Bounds.Height.ShouldBe(LayoutHarness.TitleBarHeight);
                    LayoutHarness.Unreachable(titleWindow).ShouldBeEmpty();
                }
                finally
                {
                    titleWindow.Close();
                }

                var statusBar = new StatusBar();
                var statusWindow = LayoutHarness.HostAtMinimumSize(
                    statusBar, LayoutHarness.MinimumWidth, LayoutHarness.StatusBarHeight);

                try
                {
                    statusBar.Bounds.Height.ShouldBe(LayoutHarness.StatusBarHeight);
                }
                finally
                {
                    statusWindow.Close();
                }
            },
            Token);
    }

    /// <remarks>
    /// Five destinations in a 54-pixel column. The rail runs vertically, so what runs out here is height
    /// rather than width — at the window's minimum the five entries have to leave room for each other, which
    /// is the same failure the old four-button selector was one label away from.
    /// </remarks>
    [Fact]
    public async Task TheNavRailHoldsFiveDestinationsAtTheWindowsMinimum()
    {
        await LayoutHarness.OnTheUiThreadAsync(
            () =>
            {
                var rail = new NavRail();
                var window = LayoutHarness.HostAtMinimumSize(
                    rail, LayoutHarness.NavRailWidth, LayoutHarness.ScreenHeight);

                try
                {
                    var buttons = rail.GetVisualDescendants().OfType<Button>().ToList();

                    buttons.Count.ShouldBe(5, "one per screen the rail reaches");

                    foreach (var button in buttons)
                    {
                        button.Bounds.Height.ShouldBeGreaterThan(20);

                        // One pixel narrower than the rail, because the rail draws its own divider down its
                        // right edge and that comes out of the content. Stated exactly rather than as a
                        // lower bound: a button that stopped filling the rail would leave a dead strip
                        // beside every destination, which is precisely the kind of near-miss a bound hides.
                        button.Bounds.Width.ShouldBe(LayoutHarness.NavRailWidth - 1);
                    }

                    LayoutHarness.Unreachable(window).ShouldBeEmpty();
                }
                finally
                {
                    window.Close();
                }
            },
            Token);
    }

    // ---- Helpers ----

    /// <summary>Lays the sidebar out at the width the hosts screen gives it.</summary>
    private Task MeasureSidebarAsync(Action<IReadOnlyList<string>> assert) =>
        OnTheSidebarAsync((_, window) => assert(LayoutHarness.Unreachable(window)));

    private Task OnTheSidebarAsync(Action<HostSidebar, Window> body) =>
        LayoutHarness.OnTheUiThreadAsync(
            () =>
            {
                var sidebar = new HostSidebar { DataContext = vault };

                var window = LayoutHarness.HostAtMinimumSize(
                    sidebar, LayoutHarness.HostSidebarWidth, LayoutHarness.ScreenHeight);

                try
                {
                    body(sidebar, window);
                }
                finally
                {
                    window.Close();
                }
            },
            Token);

    /// <summary>Lays the vault screen out at the width it gets once the nav rail has taken its column.</summary>
    private Task MeasureVaultAsync(Action<IReadOnlyList<string>> assert) =>
        OnTheVaultAsync((_, window) => assert(LayoutHarness.Unreachable(window)));

    private Task OnTheVaultAsync(Action<VaultScreen, Window> body) =>
        LayoutHarness.OnTheUiThreadAsync(
            () =>
            {
                var screen = new VaultScreen { DataContext = vault };

                var window = LayoutHarness.HostAtMinimumSize(
                    screen, LayoutHarness.ScreenWidth, LayoutHarness.ScreenHeight);

                try
                {
                    body(screen, window);
                }
                finally
                {
                    window.Close();
                }
            },
            Token);

    /// <remarks>
    /// Enough rows in every list that none is empty, because an empty list is the easiest case and the one
    /// least worth certifying.
    /// </remarks>
    private async Task SeedAsync()
    {
        for (var i = 0; i < 6; i++)
        {
            vault.NewHostCommand.Execute(null);
            vault.EditorLabel = $"host-{i}";
            vault.EditorHostname = $"host-{i}.internal";
            vault.EditorUsername = "deploy";
            await vault.SaveHostCommand.ExecuteAsync(null);
        }

        for (var i = 0; i < 4; i++)
        {
            vault.NewKeyCommand.Execute(null);
            vault.KeyEditorLabel = $"key-{i}";
            vault.KeyEditorPrivateKey =
                $"-----BEGIN OPENSSH PRIVATE KEY-----\nMATERIAL-{i}\n-----END OPENSSH PRIVATE KEY-----\n";
            await vault.SaveKeyCommand.ExecuteAsync(null);
        }

        for (var i = 0; i < 3; i++)
        {
            vault.NewCredentialCommand.Execute(null);
            vault.CredentialEditorLabel = $"credential-{i}";
            vault.CredentialEditorPassword = $"password-{i}";
            vault.CredentialEditorUsername = $"account-{i}";
            await vault.SaveCredentialCommand.ExecuteAsync(null);
        }

        // Pins come from approving a fingerprint at connect time, not from an editor, so they are seeded
        // through the store the connect path writes to. Two for one endpoint, because a host offering keys
        // of two algorithms is ordinary and the duplicate is one of the things this list has to show.
        foreach (var (host, algorithm) in new[]
        {
            ("host-0.internal", "ssh-ed25519"),
            ("host-0.internal", "ecdsa-sha2-nistp256"),
            ("gone.internal", "ssh-ed25519"),
        })
        {
            await knownHosts.TrustAsync(
                new HostKeyPresentation(
                    host, 22, algorithm, $"SHA256:{algorithm}-fingerprint-0123456789abcdefghijklmnop"),
                Token);
        }

        // Back to where the vault screen opens, so every test starts from the state a user would see.
        vault.Section = VaultSection.All;

        await vault.LoadAsync(Token);
    }
}