using AvParser.Core.Proxies;
using AvParser.Core.Settings;
using AvParser.UI.Services;
using AvParser.UI.ViewModels;
using ReactiveUI.Primitives.Signals;

namespace AvParser.UI.HeadlessTests;

/// <summary>
/// Test doubles for the headless tests.
/// </summary>
/// <remarks>
/// Intentionally duplicated from <c>AvParser.UI.Tests</c> rather than shared through a fourth
/// project: these are a few lines of trivial stand-ins, and a shared test-kit assembly would have
/// to opt out of the <c>tests/</c> conventions (self-executing xUnit exe) to build at all.
/// </remarks>
internal sealed class FakePage(string titleKey, string iconKey = "IconHome") : PageViewModel
{
    public override string TitleKey { get; } = titleKey;

    public override string IconKey { get; } = iconKey;
}

/// <inheritdoc cref="IThemeService" />
internal sealed class FakeThemeService(AppTheme initial = AppTheme.System) : IThemeService, IDisposable
{
    private readonly BehaviorSignal<AppTheme> _current = new(initial);

    public AppTheme Current => _current.Value;

    public IObservable<AppTheme> Changes => _current;

    public void Apply(AppTheme theme)
    {
        if (theme != _current.Value)
        {
            _current.OnNext(theme);
        }
    }

    public void Dispose() => _current.Dispose();
}

/// <summary>An editable proxy list held in memory.</summary>
internal sealed class FakeMutableProxySource : IMutableProxySource
{
    public string Id => "fake-custom";

    public string DisplayName => "Fake custom list";

    public ProxySourceKind Kind => ProxySourceKind.Custom;

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

    public Task<IReadOnlyList<ProxyEndpoint>> GetProxiesAsync(CancellationToken cancellationToken = default) =>
        Task.FromResult<IReadOnlyList<ProxyEndpoint>>(Endpoints.ToArray());

    public Task<int> AddAsync(IEnumerable<ProxyEndpoint> endpoints, CancellationToken cancellationToken = default)
    {
        Endpoints.AddRange(endpoints);
        return Task.FromResult(Endpoints.Count);
    }

    public Task<bool> RemoveAsync(ProxyEndpoint endpoint, CancellationToken cancellationToken = default) =>
        Task.FromResult(Endpoints.RemoveAll(e => e.Key == endpoint.Key) > 0);

    public Task ClearAsync(CancellationToken cancellationToken = default)
    {
        Endpoints.Clear();
        return Task.CompletedTask;
    }
}

/// <summary>A probe that says everything is dead. The view never calls it in these tests.</summary>
internal sealed class FakeProxyProbe : IProxyProbe
{
    public Task<ProxyProbeResult> ProbeAsync(
        ProxyEndpoint endpoint,
        ProxyOptions options,
        CancellationToken cancellationToken = default
    ) => Task.FromResult(ProxyProbeResult.Failure("not probed in tests"));
}