using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
using DodoSSH.Api.Features.Relay;

namespace DodoSSH.Api.Tests;

/// <summary>
/// A resolver and a dialler that reach only what a test has arranged.
/// </summary>
/// <remarks>
/// Names resolve to what <see cref="Resolve"/> says, and address literals to themselves, as the real
/// resolver does. An address dials the loopback endpoint <see cref="Route"/> mapped it to; anything
/// else is refused the way a closed port is, so a test that forgot to arrange a target sees the relay's
/// real "unreachable" path rather than a hang.
/// </remarks>
internal sealed class FakeRelayNetwork : IRelayNetwork
{
    private readonly ConcurrentDictionary<string, IPAddress[]> names = new(StringComparer.OrdinalIgnoreCase);
    private readonly ConcurrentDictionary<IPEndPoint, IPEndPoint> routes = new();
    private readonly ConcurrentQueue<IPEndPoint> dialled = new();

    /// <summary>Every endpoint the relay asked to connect to, in order.</summary>
    internal IReadOnlyCollection<IPEndPoint> Dialled => dialled;

    internal void Resolve(string name, params IPAddress[] addresses) => names[name] = addresses;

    internal void Route(IPEndPoint target, IPEndPoint loopback) => routes[target] = loopback;

    /// <inheritdoc />
    public Task<IPAddress[]> ResolveAsync(string host, CancellationToken cancellationToken)
    {
        if (IPAddress.TryParse(host, out var literal))
        {
            return Task.FromResult<IPAddress[]>([literal]);
        }

        return names.TryGetValue(host, out var addresses)
            ? Task.FromResult(addresses)
            : Task.FromException<IPAddress[]>(new SocketException((int)SocketError.HostNotFound));
    }

    /// <inheritdoc />
    public async Task<Stream> ConnectAsync(IPAddress address, int port, CancellationToken cancellationToken)
    {
        var endpoint = new IPEndPoint(address, port);
        dialled.Enqueue(endpoint);

        if (!routes.TryGetValue(endpoint, out var loopback))
        {
            throw new SocketException((int)SocketError.ConnectionRefused);
        }

        var client = new TcpClient();

        try
        {
            await client.ConnectAsync(loopback, cancellationToken);

            return client.GetStream();
        }
        catch
        {
            client.Dispose();
            throw;
        }
    }
}