using Nonemm.Core;

namespace Nonemm.Contests.Tests;

/// How many signals a multi-operator entry may have on the air, and what the
/// entry window says when there is one too many.
public class TransmitRulesTests
{
    private static readonly ContestEntry MultiOne = new()
    {
        OperatorCategory = "MULTI-ONE",
        TransmitterCategory = "ONE",
    };

    private static readonly ContestEntry MultiTwo = new()
    {
        OperatorCategory = "MULTI-TWO",
        TransmitterCategory = "TWO",
    };

    private static readonly ContestEntry Unlimited = new()
    {
        OperatorCategory = "MULTI-UNLIMITED",
        TransmitterCategory = "UNLIMITED",
    };

    private static Transmitter On(string name, Band band, ModeCategory mode = ModeCategory.Cw) =>
        new(name, band, mode);

    [Fact]
    public void OneSignalIsAlwaysAllowed() =>
        Assert.Null(TransmitRules.Violation(MultiOne, On("RUN-PC", Bands.Band20M), []));

    /// Two signals on one band and mode is wrong in every class.
    [Fact]
    public void TwoStationsOnOneBandAndModeIsNamed()
    {
        string? why = TransmitRules.Violation(
            Unlimited,
            On("RUN-PC", Bands.Band20M),
            [On("MULT-PC", Bands.Band20M)]);

        Assert.Equal("MULT-PC is transmitting on 20M CW as well", why);
    }

    [Fact]
    public void TwoStationsOnOneBandInDifferentModesIsNamed()
    {
        string? why = TransmitRules.Violation(
            Unlimited,
            On("RUN-PC", Bands.Band20M),
            [On("MULT-PC", Bands.Band20M, ModeCategory.Phone)]);

        Assert.Equal("MULT-PC is transmitting on 20M as well", why);
    }

    /// A one-transmitter entry may have one signal, wherever the other station
    /// is.
    [Fact]
    public void ASecondSignalBreaksAOneTransmitterEntry()
    {
        string? why = TransmitRules.Violation(
            MultiOne,
            On("RUN-PC", Bands.Band20M),
            [On("MULT-PC", Bands.Band40M)]);

        Assert.NotNull(why);
        Assert.Contains("one-transmitter entry", why);
        Assert.Contains("20M CW", why);
        Assert.Contains("40M CW", why);
    }

    [Fact]
    public void TwoSignalsOnDifferentBandsAreFineForTwoTransmitters() =>
        Assert.Null(TransmitRules.Violation(
            MultiTwo,
            On("RUN-PC", Bands.Band20M),
            [On("MULT-PC", Bands.Band40M)]));

    [Fact]
    public void AThirdSignalBreaksATwoTransmitterEntry()
    {
        string? why = TransmitRules.Violation(
            MultiTwo,
            On("RUN-PC", Bands.Band20M),
            [On("MULT-PC", Bands.Band40M), On("MULT2-PC", Bands.Band15M)]);

        Assert.NotNull(why);
        Assert.Contains("two-transmitter entry", why);
    }

    /// A class that does not cap the transmitters is held to the one rule that
    /// applies to everybody.
    [Fact]
    public void AnUnlimitedEntryMayHaveASignalPerBand() =>
        Assert.Null(TransmitRules.Violation(
            Unlimited,
            On("RUN-PC", Bands.Band20M),
            [On("MULT-PC", Bands.Band40M), On("MULT2-PC", Bands.Band15M)]));

    /// A station that has not said where it is counts as somewhere else. A
    /// guess here puts a red box in front of an operator doing nothing wrong.
    [Fact]
    public void AStationWithNoBandIsNotCountedAsOnThisOne() =>
        Assert.Null(TransmitRules.Violation(
            Unlimited,
            On("RUN-PC", Bands.Band20M),
            [new Transmitter("MULT-PC", null, null)]));

    /// A single operator with two radios is nobody's multi-operator entry, but
    /// two signals on one band is still two signals on one band.
    [Fact]
    public void ASingleOperatorIsOnlyHeldToTheOneBandRule()
    {
        ContestEntry single = new() { OperatorCategory = "SINGLE-OP", TransmitterCategory = "ONE" };

        Assert.Null(TransmitRules.Violation(single, On("RUN-PC", Bands.Band20M), [On("SO2R-PC", Bands.Band40M)]));
        Assert.NotNull(TransmitRules.Violation(single, On("RUN-PC", Bands.Band20M), [On("SO2R-PC", Bands.Band20M)]));
    }
}