using System;
using UnitTestSharp;

namespace Susurrus.UnitTests
{
    public class FalloffTests : TestFixture
    {
        public class CtorTests : TestFixture
        {
            public void KeepsTheDistancesAndExponent()
            {
                Falloff falloff = new Falloff(2, 10, exponent: 3f);

                CheckEqual(2.0, falloff.FullVolumeDistance.Value);
                CheckEqual(10.0, falloff.SilentDistance.Value);
                CheckEqual(3f, falloff.Exponent);
            }

            public void TheExponent_DefaultsToAStraightLine()
            {
                CheckEqual(1f, new Falloff(2, 10).Exponent);
            }

            public void AFullVolumeDistanceOfZero_IsAllowed()
            {
                CheckFalse(new Falloff(0, 10).IsNone);
            }

            public void ANegativeFullVolumeDistance_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(-1, 10);
            }

            public void AFullVolumeDistanceThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(double.NaN, 10);
            }

            public void ASilentDistanceEqualToTheFullVolumeDistance_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(5, 5);
            }

            public void ASilentDistanceNearerThanTheFullVolumeDistance_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(5, 4);
            }

            public void AnInfiniteSilentDistance_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(5, double.PositiveInfinity);
            }

            public void AnExponentOfZero_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(2, 10, exponent: 0f);
            }

            public void AnExponentThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(2, 10, exponent: float.NaN);
            }

            public void AnInfiniteExponent_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(2, 10, exponent: float.PositiveInfinity);
            }
        }

        public class NoneTests : TestFixture
        {
            public void IsNone()
            {
                CheckTrue(Falloff.None.IsNone);
            }

            public void IsTheDefault()
            {
                CheckTrue(default(Falloff).IsNone);
            }
        }

        public class GainAtTests : TestFixture
        {
            public void None_IsFullGainAtAnyDistance()
            {
                CheckEqual(1f, Falloff.None.GainAt(1e9));
            }

            public void WithinTheFullVolumeDistance_IsFullGain()
            {
                CheckEqual(1f, new Falloff(2, 10).GainAt(1));
            }

            public void AtTheFullVolumeDistance_IsFullGain()
            {
                CheckEqual(1f, new Falloff(2, 10).GainAt(2));
            }

            public void HalfwayBetweenTheDistances_IsHalfGain()
            {
                CheckEqual(0.5f, new Falloff(2, 10).GainAt(6));
            }

            public void AtTheSilentDistance_IsSilent()
            {
                CheckEqual(0f, new Falloff(2, 10).GainAt(10));
            }

            public void BeyondTheSilentDistance_IsSilent()
            {
                CheckEqual(0f, new Falloff(2, 10).GainAt(500));
            }

            public void AnExponentOfTwo_QuietsASoundSoonerThanAStraightLine()
            {
                CheckEqual(0.25f, new Falloff(2, 10, exponent: 2f).GainAt(6));
            }

            public void AnExponentBelowOne_KeepsASoundLouderThanAStraightLine()
            {
                CheckEqual(0.5f, new Falloff(2, 10, exponent: 0.5f).GainAt(8));
            }

            public void ADistanceThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(2, 10).GainAt(double.NaN);
            }

            public void ANegativeDistance_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Falloff(2, 10).GainAt(-1);
            }
        }
    }
}