using System;

namespace Amphora.UnitTests
{
    public class EventRateTests : UnitTestSharp.TestFixture
    {
        public class ChanceWithinTests : UnitTestSharp.TestFixture
        {
            public void IsOneMinusETheMinusSpanOverMean()
            {
                CheckLess(PortableMathTests.UlpsApart(0.3934693402873666, EventRate.ChanceWithin(2.0, 1.0)), 3L);
                CheckLess(PortableMathTests.UlpsApart(0.6321205588285577, EventRate.ChanceWithin(10.0, 10.0)), 3L);
                CheckLess(
                    PortableMathTests.UlpsApart(0.0003332777839501029, EventRate.ChanceWithin(3.0, 0.001)), 3L);
            }

            public void TinySpan_KeepsEveryDigit()
            {
                CheckEqual(1e-17, EventRate.ChanceWithin(1.0, 1e-17));
            }

            public void SpanFarPastTheMean_IsOne()
            {
                CheckEqual(1.0, EventRate.ChanceWithin(1.0, 40.0));
            }

            public void MeanOfZero_IsCertain()
            {
                CheckEqual(1.0, EventRate.ChanceWithin(0.0, 5.0));
            }

            public void MeanOfInfinity_IsImpossible()
            {
                CheckEqual(0.0, EventRate.ChanceWithin(double.PositiveInfinity, 5.0));
                CheckEqual(0.0, EventRate.ChanceWithin(double.PositiveInfinity, double.PositiveInfinity));
            }

            public void SpanOfZero_IsImpossible()
            {
                CheckEqual(0.0, EventRate.ChanceWithin(5.0, 0.0));
                CheckEqual(0.0, EventRate.ChanceWithin(0.0, 0.0));
            }

            public void InfiniteSpan_IsCertain()
            {
                CheckEqual(1.0, EventRate.ChanceWithin(5.0, double.PositiveInfinity));
            }

            public void NegativeMean_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.ChanceWithin(-1.0, 5.0);
            }

            public void NotANumberMean_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.ChanceWithin(double.NaN, 5.0);
            }

            public void NegativeSpan_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.ChanceWithin(5.0, -1.0);
            }

            public void NotANumberSpan_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.ChanceWithin(5.0, double.NaN);
            }
        }

        public class MeanForTests : UnitTestSharp.TestFixture
        {
            public void IsTheIntervalOverMinusTheLogOfOneMinusTheChance()
            {
                CheckLess(PortableMathTests.UlpsApart(14.426950408889635, EventRate.MeanFor(0.5, 10.0)), 3L);
                CheckLess(PortableMathTests.UlpsApart(28.03673252057129, EventRate.MeanFor(0.3, 10.0)), 3L);
                CheckLess(PortableMathTests.UlpsApart(0.2171472409516259, EventRate.MeanFor(0.99, 1.0)), 3L);
            }

            public void TinyChance_KeepsEveryDigit()
            {
                CheckEqual(1e+20, EventRate.MeanFor(1e-20, 1.0));
            }

            public void ChanceOfOneOrMore_IsZero()
            {
                CheckEqual(0.0, EventRate.MeanFor(1.0, 10.0));
                CheckEqual(0.0, EventRate.MeanFor(2.0, 10.0));
                CheckEqual(0.0, EventRate.MeanFor(double.PositiveInfinity, 10.0));
            }

            public void ChanceOfZeroOrLess_IsInfinity()
            {
                CheckEqual(double.PositiveInfinity, EventRate.MeanFor(0.0, 10.0));
                CheckEqual(double.PositiveInfinity, EventRate.MeanFor(-0.5, 10.0));
                CheckEqual(double.PositiveInfinity, EventRate.MeanFor(0.0, 0.0));
            }

            public void IntervalOfZero_IsZero()
            {
                CheckEqual(0.0, EventRate.MeanFor(0.5, 0.0));
            }

            public void InfiniteInterval_IsInfinity()
            {
                CheckEqual(double.PositiveInfinity, EventRate.MeanFor(0.5, double.PositiveInfinity));
            }

            public void GivesTheMeanWhoseChanceIsTheOneAsked()
            {
                double mean = EventRate.MeanFor(0.3, 10.0);

                CheckLess(Math.Abs(EventRate.ChanceWithin(mean, 10.0) - 0.3), 1e-15);
            }

            public void TinyChance_RoundTripsToTheSameChance()
            {
                double mean = EventRate.MeanFor(1e-12, 1.0);

                CheckLess(Math.Abs(EventRate.ChanceWithin(mean, 1.0) / 1e-12 - 1.0), 1e-14);
            }

            public void NotANumberChance_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.MeanFor(double.NaN, 10.0);
            }

            public void NegativeInterval_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.MeanFor(0.5, -1.0);
            }

            public void NotANumberInterval_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                EventRate.MeanFor(0.5, double.NaN);
            }
        }
    }
}