using System;
using System.Collections.Generic;
using NUnit.Framework;
using pflib_net.dice;

namespace pflib_net.Tests;

[TestFixture]
[TestOf(typeof(Dice))]
public class DiceTest
{
    private static IEnumerable<Func<Dice, Dice>> OperationCases
    {
        get
        {
            yield return (dice) => dice.Kh(1);
            yield return (dice) => dice.Kl(1);
        }
    }

    [Test]
    [Repeat(100)]
    public void D20RollProducesValueBetween1And20()
    {
        var die = new Dice(20);
        Assert.That(die.Roll(), Is.InRange(1, 20));
    }

    [Test]
    [TestCase(10)]
    [TestCase(-10)]
    public void RollAddsValuesCorrectly(int value)
    {
        var die = new Dice(4, add: value);
        Assert.That(die.Roll(), Is.InRange(1 + value, 4 + value));
    }

    [Test]
    [Repeat(100)]
    public void RollMultipleDiceHasCorrectAmountOfDice()
    {
        var dice = new Dice(4, 20);
        Assert.That(dice.Roll(), Is.InRange(20, 4 * 20));
    }

    [Test]
    public void KeepHighestHasCorrectNumberOfDice()
    {
        var dice = new Dice(1, 40, 20);
        Assert.That(dice.Roll(), Is.EqualTo(20));
    }

    [Test]
    public void KeepLowestHasCorrectNumberOfDice()
    {
        var dice = new Dice(1, 40, keepLowest: 20);
        Assert.That(dice.Roll(), Is.EqualTo(20));
    }

    [Test]
    public void CannotSetKeepHighestAndKeepLowest()
    {
        Assert.Throws<InvalidOperationException>(
            () => new Dice(1, 40, 1, 1));
    }

    [Test]
    [TestCaseSource(nameof(OperationCases))]
    [Repeat(100)]
    public void CanBuildUsingIntExtension(Func<Dice, Dice> func)
    {
        var dice = func(2.D(6));
        Assert.That(dice.Roll(), Is.InRange(1, 6));
    }

    [Test]
    public void KhAndKlTogetherFails()
    {
        Assert.Throws<InvalidOperationException>(
            () => 1.D(6).Kh(1).Kl(1));
        Assert.Throws<InvalidOperationException>(
            () => 1.D(6).Kl(1).Kh(1));
    }
}