using SSPCTester.Logic.Testing;
using SSPCTester.Devices.Interfaces;

namespace SSPCTester.Tests;

public sealed class BasicTestCriteriaTests
{
    [Theory]
    [InlineData(1.01, true)]
    [InlineData(1.00, false)]
    [InlineData(0.99, false)]
    public void IsOn_UsesStrictConductingThreshold(double voltage, bool expected)
    {
        Assert.Equal(expected, BasicTestCriteria.IsOn(voltage));
    }

    [Theory]
    [InlineData(0.29, true)]
    [InlineData(-0.29, true)]
    [InlineData(0.30, false)]
    [InlineData(-0.30, false)]
    public void IsOff_UsesAbsoluteVoltageThreshold(double voltage, bool expected)
    {
        Assert.Equal(expected, BasicTestCriteria.IsOff(voltage));
    }

    [Theory]
    [InlineData(28.0, 1.0, true)]
    [InlineData(28.0, 0.0, false)]
    [InlineData(0.0, 1.0, false)]
    public void IsOnState_RequiresVoltageAndCurrentData(double voltage, double current, bool expected)
    {
        Assert.Equal(expected, BasicTestCriteria.IsOnState(voltage, current));
    }

    [Theory]
    [InlineData(0.0, 0.0, true)]
    [InlineData(0.29, 0.0, true)]
    [InlineData(-0.29, 0.0, true)]
    [InlineData(0.0, 0.29, true)]
    [InlineData(0.30, 0.0, false)]
    [InlineData(0.75, 0.0, false)]
    [InlineData(0.0, 0.30, false)]
    [InlineData(28.0, 0.0, false)]
    public void IsOffState_RequiresNoVoltageAndNoCurrent(double voltage, double current, bool expected)
    {
        Assert.Equal(expected, BasicTestCriteria.IsOffState(voltage, current));
    }

    [Fact]
    public async Task WaitForStableOffAsync_ReportsEachSample()
    {
        var readings = new[]
        {
            new ChannelMeasurement { PhysicalSlot = 3, Voltage = 0.1, Current = 0.0 },
            new ChannelMeasurement { PhysicalSlot = 3, Voltage = 0.0, Current = 0.0 }
        };
        var sspc = new SequenceSspc(readings);
        var samples = new List<ChannelMeasurement>();

        var result = await BasicTestCriteria.WaitForStableOffAsync(sspc, 3, onSample: samples.Add);

        Assert.True(result.IsStableOff);
        Assert.Equal(2, samples.Count);
        Assert.Equal(0.1, samples[0].Voltage);
        Assert.Equal(0.0, samples[0].Current);
        Assert.Equal(0.0, result.Measurement.Voltage);
    }

    private sealed class SequenceSspc : ISspc
    {
        private readonly Queue<ChannelMeasurement> _readings;

        public SequenceSspc(IEnumerable<ChannelMeasurement> readings)
        {
            _readings = new Queue<ChannelMeasurement>(readings);
        }

        public int ChannelCount => 24;
        public bool IsConnected => true;
        public string DisplayName => "Sequence SSPC";
        public event EventHandler<bool>? ConnectionChanged;

        public Task<bool> ConnectAsync(CancellationToken ct = default)
        {
            ConnectionChanged?.Invoke(this, true);
            return Task.FromResult(true);
        }

        public Task DisconnectAsync() => Task.CompletedTask;
        public Task TurnOnAsync(int physicalSlot, CancellationToken ct = default) => Task.CompletedTask;
        public Task TurnOffAsync(int physicalSlot, CancellationToken ct = default) => Task.CompletedTask;
        public Task FlashAsync(int physicalSlot, int milliseconds, CancellationToken ct = default) => Task.CompletedTask;
        public Task<bool> GetChannelStateAsync(int physicalSlot, CancellationToken ct = default) => Task.FromResult(false);

        public Task<ChannelMeasurement> ReadMeasurementAsync(int physicalSlot, CancellationToken ct = default)
        {
            if (_readings.Count > 1)
                return Task.FromResult(_readings.Dequeue());

            return Task.FromResult(_readings.Peek());
        }

        public Task<IReadOnlyList<ChannelMeasurement>> ReadMeasurementsAsync(CancellationToken ct = default) =>
            Task.FromResult<IReadOnlyList<ChannelMeasurement>>(_readings.ToArray());
    }
}