using System;
using UnitTestSharp;

namespace Susurrus.UnitTests
{
    public class VolumeTests : TestFixture
    {
        public class CheckTests : TestFixture
        {
            public void Zero_IsAllowed()
            {
                Volume.Check(0f, "volume");
            }

            public void One_IsAllowed()
            {
                Volume.Check(1f, "volume");
            }

            public void AGainAboveOne_IsAllowed()
            {
                Volume.Check(4f, "volume");
            }

            public void Negative_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.Check(-0.5f, "volume");
            }

            public void NotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.Check(float.NaN, "volume");
            }

            public void PositiveInfinity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.Check(float.PositiveInfinity, "volume");
            }

            public void NegativeInfinity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.Check(float.NegativeInfinity, "volume");
            }

            public void NamesTheParameterItWasGiven()
            {
                string thrownFor = null;

                try
                {
                    Volume.Check(-1f, "loudness");
                }
                catch (ArgumentOutOfRangeException exception)
                {
                    thrownFor = exception.ParamName;
                }

                CheckEqual("loudness", thrownFor);
            }
        }

        public static bool Near(float expected, float actual)
        {
            return Math.Abs(expected - actual) < 1e-6f;
        }

        public class FromDecibelsTests : TestFixture
        {
            public void ZeroDecibels_IsAGainOfOne()
            {
                CheckEqual(1f, Volume.FromDecibels(0f));
            }

            public void TwentyDecibels_IsAGainOfTen()
            {
                CheckEqual(10f, Volume.FromDecibels(20f));
            }

            public void MinusTwentyDecibels_IsAGainOfATenth()
            {
                CheckTrue(Near(0.1f, Volume.FromDecibels(-20f)));
            }

            public void NegativeInfinity_IsSilent()
            {
                CheckEqual(0f, Volume.FromDecibels(float.NegativeInfinity));
            }

            public void PositiveInfinity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromDecibels(float.PositiveInfinity);
            }

            public void NotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromDecibels(float.NaN);
            }
        }

        public class ToDecibelsTests : TestFixture
        {
            public void AGainOfOne_IsZeroDecibels()
            {
                CheckEqual(0f, Volume.ToDecibels(1f));
            }

            public void AGainOfTen_IsTwentyDecibels()
            {
                CheckEqual(20f, Volume.ToDecibels(10f));
            }

            public void Silence_IsNegativeInfinity()
            {
                CheckEqual(float.NegativeInfinity, Volume.ToDecibels(0f));
            }

            public void AGainOfAHalf_IsAboutMinusSixDecibels()
            {
                CheckTrue(Math.Abs(-6.0206f - Volume.ToDecibels(0.5f)) < 1e-3f);
            }

            public void ANegativeGain_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.ToDecibels(-1f);
            }
        }

        public class FromSliderTests : TestFixture
        {
            public void TheTop_IsAGainOfOne()
            {
                CheckEqual(1f, Volume.FromSlider(1f, floorDecibels: -60f));
            }

            public void TheBottom_IsSilent()
            {
                CheckEqual(0f, Volume.FromSlider(0f, floorDecibels: -60f));
            }

            public void TheMiddle_IsHalfwayDownInDecibels()
            {
                CheckTrue(Near(0.1f, Volume.FromSlider(0.5f, floorDecibels: -40f)));
            }

            public void JustAboveTheBottom_IsNearTheFloor()
            {
                CheckTrue(Math.Abs(0.01f - Volume.FromSlider(1e-6f, floorDecibels: -40f)) < 1e-4f);
            }

            public void APositionBelowZero_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromSlider(-0.1f, floorDecibels: -60f);
            }

            public void APositionAboveOne_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromSlider(1.1f, floorDecibels: -60f);
            }

            public void APositionThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromSlider(float.NaN, floorDecibels: -60f);
            }

            public void AFloorOfZero_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromSlider(0.5f, floorDecibels: 0f);
            }

            public void AnInfiniteFloor_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromSlider(0.5f, floorDecibels: float.NegativeInfinity);
            }

            public void AFloorThatIsNotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Volume.FromSlider(0.5f, floorDecibels: float.NaN);
            }
        }
    }
}