using DodoSSH.Client.Ssh;

namespace DodoSSH.Client.App.Tests;

/// <summary>
/// An SSH stack that connects to nothing.
/// </summary>
/// <remarks>
/// The shell suite is about what the view models do, and the real factory would need a reachable
/// sshd — which <c>DodoSSH.Client.Ssh.Tests</c> already covers against a container. What this makes
/// testable is everything the connect path does <em>around</em> the connection.
/// </remarks>
internal sealed class FakeSshConnectionFactory : ISshConnectionFactory
{
    /// <summary>Thrown instead of connecting, when set. Used for the host-key paths.</summary>
    internal Exception? Failure { get; set; }

    /// <summary>Requests this factory was asked for, in order.</summary>
    internal List<SshConnectionRequest> Requests { get; } = [];

    /// <inheritdoc />
    public Task<ISshConnection> ConnectAsync(
        SshConnectionRequest request,
        CancellationToken cancellationToken)
    {
        Requests.Add(request);

        return Failure is { } failure
            ? Task.FromException<ISshConnection>(failure)
            : Task.FromResult<ISshConnection>(new FakeSshConnection(request));
    }
}

internal sealed class FakeSshConnection(SshConnectionRequest request) : ISshConnection
{
    /// <inheritdoc />
    public bool IsConnected { get; private set; } = true;

    /// <inheritdoc />
    public HostKeyPresentation HostKey { get; } =
        new(request.Host, request.Port, "ssh-ed25519", "SHA256:fake");

    /// <inheritdoc />
    public Task<ISshShellSession> OpenShellAsync(
        TerminalSize size,
        CancellationToken cancellationToken) =>
        Task.FromResult<ISshShellSession>(new FakeSshShellSession());

    /// <inheritdoc />
    public ValueTask DisposeAsync()
    {
        IsConnected = false;
        return ValueTask.CompletedTask;
    }
}

/// <summary>A shell that is open, silent and never closes on its own.</summary>
/// <remarks>
/// <see cref="ReadAsync"/> blocks rather than returning 0. Returning 0 means the remote closed the
/// channel, which would end the session the moment it was opened and make the test assert against a
/// connection that had already gone.
/// </remarks>
internal sealed class FakeSshShellSession : ISshShellSession
{
    private readonly CancellationTokenSource closed = new();

    /// <inheritdoc />
    public bool IsOpen { get; private set; } = true;

    /// <inheritdoc />
    public async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
    {
        using var linked = CancellationTokenSource.CreateLinkedTokenSource(
            cancellationToken, closed.Token);

        await Task.Delay(Timeout.InfiniteTimeSpan, linked.Token).ConfigureAwait(false);

        return 0;
    }

    /// <inheritdoc />
    public ValueTask WriteAsync(ReadOnlyMemory<byte> data, CancellationToken cancellationToken) =>
        ValueTask.CompletedTask;

    /// <inheritdoc />
    public void Resize(TerminalSize size)
    {
    }

    /// <inheritdoc />
    public async ValueTask DisposeAsync()
    {
        IsOpen = false;

        await closed.CancelAsync().ConfigureAwait(false);

        closed.Dispose();
    }
}