using AvParser.Core.Proxies;

namespace AvParser.Core.Tests.Proxies;

/// <summary>A clock the tests move by hand, so quarantine expiry is deterministic.</summary>
internal sealed class FakeTimeProvider(DateTimeOffset start) : TimeProvider
{
    private DateTimeOffset _now = start;

    public FakeTimeProvider()
        : this(new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero)) { }

    public override DateTimeOffset GetUtcNow() => _now;

    public void Advance(TimeSpan delta) => _now += delta;
}

/// <summary>A source that returns whatever the test handed it.</summary>
internal sealed class FakeProxySource(ProxySourceKind kind = ProxySourceKind.Feed, params ProxyEndpoint[] endpoints)
    : IProxySource
{
    public string Id { get; init; } = "fake";

    public string DisplayName => "Fake source";

    public ProxySourceKind Kind { get; } = kind;

    public List<ProxyEndpoint> Endpoints { get; } = [.. endpoints];

    public int GetCallCount { get; private set; }

    public Task<IReadOnlyList<ProxyEndpoint>> GetProxiesAsync(CancellationToken cancellationToken = default)
    {
        GetCallCount++;
        return Task.FromResult<IReadOnlyList<ProxyEndpoint>>(Endpoints.ToArray());
    }
}

/// <summary>A probe whose verdict the test decides, per address.</summary>
internal sealed class FakeProxyProbe : IProxyProbe
{
    private readonly Dictionary<string, bool> _verdicts = new(StringComparer.Ordinal);

    /// <summary>Verdict for addresses with no explicit entry.</summary>
    public bool DefaultAlive { get; set; }

    /// <summary>How many probes were requested.</summary>
    public int ProbeCount { get; private set; }

    /// <summary>Addresses probed, in order.</summary>
    public List<string> Probed { get; } = [];

    public FakeProxyProbe Set(ProxyEndpoint endpoint, bool alive)
    {
        _verdicts[endpoint.Key] = alive;
        return this;
    }

    public Task<ProxyProbeResult> ProbeAsync(
        ProxyEndpoint endpoint,
        ProxyOptions options,
        CancellationToken cancellationToken = default
    )
    {
        ProbeCount++;
        Probed.Add(endpoint.Key);

        var alive = _verdicts.TryGetValue(endpoint.Key, out var verdict) ? verdict : DefaultAlive;

        return Task.FromResult(
            alive ? ProxyProbeResult.Success(TimeSpan.FromMilliseconds(42)) : ProxyProbeResult.Failure("dead")
        );
    }
}

/// <summary>Shorthand builders for the proxy tests.</summary>
internal static class ProxyFactory
{
    public static ProxyEndpoint Endpoint(
        string host,
        int port = 8080,
        ProxyProtocol protocol = ProxyProtocol.Http,
        int score = 0
    ) => new(protocol, host, port) { Score = score };

    public static ProxyEntry Entry(
        string host,
        int port = 8080,
        ProxyProtocol protocol = ProxyProtocol.Http,
        int score = 0,
        ProxySourceKind source = ProxySourceKind.Feed
    ) => new(Endpoint(host, port, protocol, score), source);
}