using DodoSSH.Client.Ssh;

namespace DodoSSH.Client.App.Tests;

/// <summary>
/// An SSH layer that connects to nothing and hands out shells that simply stay open.
/// </summary>
/// <remarks>
/// This suite has no network and no <c>sshd</c>; what it needs from a session is only that one can exist
/// and outlive a lock. The real factory was here before and was never called by anything, which made the
/// suite's independence from the network a coincidence rather than a property.
/// </remarks>
internal sealed class IdleSshConnectionFactory : ISshConnectionFactory
{
    /// <inheritdoc />
    public Task<ISshConnection> ConnectAsync(
        SshConnectionRequest request,
        CancellationToken cancellationToken) =>
        Task.FromResult<ISshConnection>(new IdleConnection(request));
}

/// <summary>A connection whose shells never end by themselves.</summary>
internal sealed class IdleConnection(SshConnectionRequest request) : ISshConnection
{
    /// <inheritdoc />
    public bool IsConnected { get; private set; } = true;

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

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

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

        return ValueTask.CompletedTask;
    }
}

/// <summary>
/// A shell that is connected, silent, and ends only when something ends it.
/// </summary>
/// <remarks>
/// Which is what the interesting case looks like from the host's side: a remote sitting in the middle of
/// a long job produces nothing for minutes and must not be mistaken for one that has exited.
/// </remarks>
internal sealed class IdleShell : ISshShellSession
{
    /// <inheritdoc />
    public bool IsOpen { get; private set; } = true;

    /// <inheritdoc />
    public async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
    {
        // Never returns 0 of its own accord: 0 would tell the pump the remote closed the channel, which
        // is the opposite of what this stands in for.
        await Task.Delay(System.Threading.Timeout.InfiniteTimeSpan, cancellationToken)
            .ConfigureAwait(false);

        return 0;
    }

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

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

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

        return ValueTask.CompletedTask;
    }
}