using System;
using UnitTestSharp;

namespace Susurrus.UnitTests
{
    public class PitchTests : TestFixture
    {
        public static bool Near(float expected, float actual)
        {
            return Math.Abs(expected - actual) < 1e-4f;
        }

        public class ConstantsTests : TestFixture
        {
            public void NaturalIsOne()
            {
                CheckEqual(1f, Pitch.Natural);
            }

            public void TheRangeIsTenOctavesEitherWay()
            {
                CheckEqual(1024f, Pitch.Max);
                CheckEqual(1f / 1024f, Pitch.Min);
                CheckEqual(120f, Pitch.MaxSemitones);
            }
        }

        public class CheckTests : TestFixture
        {
            public void Natural_IsAllowed()
            {
                Pitch.Check(Pitch.Natural, "pitch");
            }

            public void TheLowestPitch_IsAllowed()
            {
                Pitch.Check(Pitch.Min, "pitch");
            }

            public void TheHighestPitch_IsAllowed()
            {
                Pitch.Check(Pitch.Max, "pitch");
            }

            public void JustBelowTheLowest_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.Check(Pitch.Min * 0.99f, "pitch");
            }

            public void JustAboveTheHighest_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.Check(Pitch.Max * 1.01f, "pitch");
            }

            public void Zero_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.Check(0f, "pitch");
            }

            public void Negative_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.Check(-1f, "pitch");
            }

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

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

            public void NamesTheParameterItWasGiven()
            {
                string thrownFor = null;

                try
                {
                    Pitch.Check(0f, "speed");
                }
                catch (ArgumentOutOfRangeException exception)
                {
                    thrownFor = exception.ParamName;
                }

                CheckEqual("speed", thrownFor);
            }
        }

        public class FromSemitonesTests : TestFixture
        {
            public void Zero_IsNatural()
            {
                CheckEqual(1f, Pitch.FromSemitones(0f));
            }

            public void TwelveSemitones_AreAnOctaveUp()
            {
                CheckEqual(2f, Pitch.FromSemitones(12f));
            }

            public void MinusTwelveSemitones_AreAnOctaveDown()
            {
                CheckEqual(0.5f, Pitch.FromSemitones(-12f));
            }

            public void OneSemitone_IsTheTwelfthRootOfTwo()
            {
                CheckTrue(Near(1.0594631f, Pitch.FromSemitones(1f)));
            }

            public void TheMostSemitonesUp_IsTheHighestPitch()
            {
                CheckEqual(Pitch.Max, Pitch.FromSemitones(Pitch.MaxSemitones));
            }

            public void TheMostSemitonesDown_IsTheLowestPitch()
            {
                CheckEqual(Pitch.Min, Pitch.FromSemitones(-Pitch.MaxSemitones));
            }

            public void BeyondTheMostUp_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.FromSemitones(120.5f);
            }

            public void BeyondTheMostDown_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.FromSemitones(-120.5f);
            }

            public void NotANumber_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.FromSemitones(float.NaN);
            }

            public void Infinity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.FromSemitones(float.PositiveInfinity);
            }
        }

        public class ToSemitonesTests : TestFixture
        {
            public void Natural_IsZero()
            {
                CheckEqual(0f, Pitch.ToSemitones(1f));
            }

            public void AnOctaveUp_IsTwelve()
            {
                CheckTrue(Near(12f, Pitch.ToSemitones(2f)));
            }

            public void AnOctaveDown_IsMinusTwelve()
            {
                CheckTrue(Near(-12f, Pitch.ToSemitones(0.5f)));
            }

            public void TheHighestPitch_IsTheMostSemitones()
            {
                CheckTrue(Near(Pitch.MaxSemitones, Pitch.ToSemitones(Pitch.Max)));
            }

            public void AnUnplayablePitch_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Pitch.ToSemitones(0f);
            }
        }
    }
}