using Nonemm.Contests;
using Nonemm.Contests.Rules;
using Nonemm.Core;
using Nonemm.Core.Country;
using Nonemm.Storage;

namespace Nonemm.Session.Tests;

/// What the stacking keys do to the entry: N1MM's Ctrl+Alt+G, Alt+G and
/// {SOCALLSTACK}.
public class CallStackingTests
{
    private const string Countries = """
        Germany:                  14:  28:  EU:   51.00:  -10.00:   -1.0:  DL:
            DL,DK,DJ;
        Japan:                    25:  45:  AS:   36.40: -138.38:   -9.0:  JA:
            JA,JH,JR;
        """;

    private static readonly StationInfo Me = new()
    {
        Callsign = "DL1ABC",
        CqZone = 14,
        ItuZone = 28,
        Continent = "EU",
        CountryPrefix = "DL",
    };

    private static OperatingPosition Running()
    {
        FakeLogStore store = new();
        ContestInstance instance = store.AddContest(new ContestInstance
        {
            ContestNumber = 0,
            ContestName = "CQWW",
        });
        ContestSession session = new(
            store,
            new CqWorldWide(ModeCategory.Cw),
            instance,
            Me,
            CountryFile.Parse(Countries));
        return new OperatingPosition(session) { IsRunning = true };
    }

    private static void Type(OperatingPosition position, string call, string zone = "25")
    {
        position.Entry.Call = call;
        position.Entry.Set(ExchangeSlot.ReceivedReport, "599");
        position.Entry.Set(ExchangeSlot.Zone, zone);
    }

    [Fact]
    public void StackAnotherPutsTheCallOnTheStackAndClearsTheEntry()
    {
        OperatingPosition position = Running();
        Type(position, "JA1XYZ");

        Assert.True(position.StackAnother());
        Assert.Equal(["JA1XYZ"], position.Stack.Calls);
        Assert.Equal("", position.Entry.Call);
    }

    [Fact]
    public void NothingIsStackedWhileSearching()
    {
        OperatingPosition position = Running();
        position.IsRunning = false;
        Type(position, "JA1XYZ");

        Assert.False(position.StackAnother());
        Assert.True(position.Stack.IsEmpty);
        Assert.Equal("JA1XYZ", position.Entry.Call);
    }

    [Fact]
    public void ADupeIsNotStacked()
    {
        OperatingPosition position = Running();
        Type(position, "JA1XYZ");
        position.LogContact();
        Type(position, "JA1XYZ");

        Assert.False(position.StackAnother());
        Assert.True(position.Stack.IsEmpty);
    }

    [Fact]
    public void AFrequencyTypedIntoTheCallsignBoxIsNotStacked()
    {
        OperatingPosition position = Running();
        position.Entry.Call = "14025";

        Assert.False(position.StackAnother());
        Assert.True(position.Stack.IsEmpty);
    }

    /// N1MM refuses your own call only while the stack is empty. It is never
    /// a station to work, so it is refused either way here.
    [Fact]
    public void OurOwnCallIsNotStacked()
    {
        OperatingPosition position = Running();
        position.Stack.Add("JA1XYZ", isMultiplier: false);
        Type(position, "DL1ABC", "14");

        Assert.False(position.StackAnother());
        Assert.Equal(["JA1XYZ"], position.Stack.Calls);
    }

    [Fact]
    public void GrabbingPutsTheTopCallInTheBox()
    {
        OperatingPosition position = Running();
        position.Stack.Add("JA1XYZ", isMultiplier: false);
        position.Stack.Add("G4ABC", isMultiplier: false);

        Assert.True(position.GrabStacked());
        Assert.Equal("JA1XYZ", position.Entry.Call);
        Assert.Equal(["G4ABC"], position.Stack.Calls);
    }

    [Fact]
    public void GrabbingFromAnEmptyStackLeavesTheEntryAlone()
    {
        OperatingPosition position = Running();
        Type(position, "JA1XYZ");

        Assert.False(position.GrabStacked());
        Assert.Equal("JA1XYZ", position.Entry.Call);
    }

    [Fact]
    public void SwappingExchangesTheTypedCallForTheStackedOne()
    {
        OperatingPosition position = Running();
        position.Stack.Add("G4ABC", isMultiplier: false);
        Type(position, "JA1XYZ");

        Assert.True(position.SwapWithStack());
        Assert.Equal("G4ABC", position.Entry.Call);
        Assert.Equal(["JA1XYZ"], position.Stack.Calls);
    }

    /// The stacked call comes off before the typed one goes on, so a typed
    /// multiplier cannot come straight back into the box.
    [Fact]
    public void SwappingTakesTheStackedCallEvenWhenTheTypedOneIsAMultiplier()
    {
        OperatingPosition position = Running();
        position.Stack.Add("G4ABC", isMultiplier: false);
        Type(position, "JA1XYZ");

        position.SwapWithStack();

        Assert.Equal("G4ABC", position.Entry.Call);
    }

    [Fact]
    public void SwappingWithAnEmptyStackJustStacksTheTypedCall()
    {
        OperatingPosition position = Running();
        Type(position, "JA1XYZ");

        Assert.False(position.SwapWithStack());
        Assert.Equal(["JA1XYZ"], position.Stack.Calls);
        Assert.Equal("", position.Entry.Call);
    }

    [Fact]
    public void SwappingWithAnEmptyBoxTakesTheNextCall()
    {
        OperatingPosition position = Running();
        position.Stack.Add("G4ABC", isMultiplier: false);

        Assert.True(position.SwapWithStack());
        Assert.Equal("G4ABC", position.Entry.Call);
        Assert.True(position.Stack.IsEmpty);
    }

    [Fact]
    public void SwappingWithNothingTypedAndNothingStackedDoesNothing()
    {
        OperatingPosition position = Running();

        Assert.False(position.SwapWithStack());
        Assert.True(position.Stack.IsEmpty);
        Assert.Equal("", position.Entry.Call);
    }
}