using Amphora;
using System;
using UnitTestSharp;

namespace Azimuth.UnitTests
{
    public class VariationTests : TestFixture
    {
        public class NoneTests : TestFixture
        {
            public void IsEmptyAndRunsFromZeroToZero()
            {
                CheckTrue(Variation.None.IsEmpty);
                CheckEqual(0.0, Variation.None.Minimum.Value);
                CheckEqual(0.0, Variation.None.Maximum.Value);
            }

            public void IsWhatADefaultVariationIs()
            {
                CheckTrue(default(Variation).IsEmpty);
            }
        }

        public class CtorTests : TestFixture
        {
            public void KeepsBothEnds()
            {
                Variation variation = new Variation(-2, 3);

                CheckEqual(-2.0, variation.Minimum.Value);
                CheckEqual(3.0, variation.Maximum.Value);
            }

            public void EqualEnds_AreAllowed()
            {
                CheckTrue(new Variation(1, 1).IsEmpty);
            }

            public void AMaximumBelowTheMinimum_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Variation(1, 0);
            }

            public void AMaximumJustBelowTheMinimum_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Variation(1.0, 1.0 - 1e-12);
            }

            public void AMinimumThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Variation(double.NaN, 0);
            }

            public void AnInfiniteMinimum_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Variation(double.NegativeInfinity, 0);
            }

            public void AMaximumThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Variation(0, double.NaN);
            }

            public void AnInfiniteMaximum_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Variation(0, double.PositiveInfinity);
            }
        }

        public class ImplicitConversionTests : TestFixture
        {
            public void FromADouble_IsAVariationOfThatOneValue()
            {
                Variation variation = 7.0;

                CheckEqual(7.0, variation.Minimum.Value);
                CheckEqual(7.0, variation.Maximum.Value);
                CheckTrue(variation.IsEmpty);
            }

            public void FromAFloat_IsAVariationOfThatOneValue()
            {
                Variation variation = 2.5f;

                CheckEqual(2.5, variation.Minimum.Value);
                CheckEqual(2.5, variation.Maximum.Value);
            }

            public void FromAScalar_IsAVariationOfThatOneValue()
            {
                Scalar value = 3;
                Variation variation = value;

                CheckEqual(3.0, variation.Minimum.Value);
                CheckEqual(3.0, variation.Maximum.Value);
            }

            public void FromAnInteger_IsAVariationOfThatOneValue()
            {
                Variation variation = 4;

                CheckEqual(4.0, variation.Minimum.Value);
                CheckEqual(4.0, variation.Maximum.Value);
            }

            public void FromANumberThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Variation variation = double.NaN;
            }

            public void FromAnInfinity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Variation variation = double.PositiveInfinity;
            }

            public void ADrawFromIt_ReturnsThatValueAndTakesNoRandomNumber()
            {
                ScriptedGenerator random = new ScriptedGenerator(ScriptedGenerator.WordForUnit(0.5));
                Variation variation = 7.0;

                CheckEqual(7.0, variation.Next(random).Value);
                CheckEqual(1, random.Remaining);
            }
        }

        public class IsEmptyTests : TestFixture
        {
            public void ARangeWithWidth_IsNotEmpty()
            {
                CheckFalse(new Variation(0, 0.001).IsEmpty);
            }

            public void ARangeWithAWidthTooSmallForScalarToSee_IsNotEmpty()
            {
                CheckFalse(new Variation(1.0, 1.0 + 1e-12).IsEmpty);
            }

            public void ARangeWithNoWidth_IsEmpty()
            {
                CheckTrue(new Variation(5, 5).IsEmpty);
            }
        }

        public class PlusOrMinusTests : TestFixture
        {
            public void RunsTheAmountEitherSideOfZero()
            {
                Variation variation = Variation.PlusOrMinus(2);

                CheckEqual(-2.0, variation.Minimum.Value);
                CheckEqual(2.0, variation.Maximum.Value);
            }

            public void Zero_IsEmpty()
            {
                CheckTrue(Variation.PlusOrMinus(0).IsEmpty);
            }

            public void ANegativeAmount_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Variation.PlusOrMinus(-1);
            }

            public void AnAmountThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Variation.PlusOrMinus(double.NaN);
            }

            public void AnInfiniteAmount_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Variation.PlusOrMinus(double.PositiveInfinity);
            }
        }

        public class NextTests : TestFixture
        {
            public void ADrawAtTheBottomOfTheUnit_ReturnsTheMinimum()
            {
                ScriptedGenerator random = new ScriptedGenerator(ScriptedGenerator.WordForUnit(0.0));

                CheckEqual(-16.0, new Variation(-16, 0).Next(random).Value);
            }

            public void ADrawHalfwayThroughTheUnit_ReturnsTheMiddle()
            {
                ScriptedGenerator random = new ScriptedGenerator(ScriptedGenerator.WordForUnit(0.5));

                CheckTrue(Math.Abs(8.0 - new Variation(0, 16).Next(random).Value) < 1e-9);
                CheckEqual(0, random.Remaining);
            }

            public void AnEmptyVariation_ReturnsItsMinimumAndTakesNoDraw()
            {
                ScriptedGenerator random = new ScriptedGenerator(ScriptedGenerator.WordForUnit(0.5));

                CheckEqual(5.0, new Variation(5, 5).Next(random).Value);
                CheckEqual(1, random.Remaining);
            }

            public void None_ReturnsZeroAndTakesNoDraw()
            {
                ScriptedGenerator random = new ScriptedGenerator(ScriptedGenerator.WordForUnit(0.5));

                CheckEqual(0.0, Variation.None.Next(random).Value);
                CheckEqual(1, random.Remaining);
            }

            public void ANullRandom_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new Variation(0, 1).Next(null);
            }
        }
    }
}