using System;
using UnitTestSharp;

namespace Susurrus.UnitTests
{
    public class LoopTests : TestFixture
    {
        public static TimeSpan Seconds(double seconds)
        {
            return TimeSpan.FromSeconds(seconds);
        }

        public class NoneTests : TestFixture
        {
            public void DoesNotLoop()
            {
                CheckFalse(Loop.None.IsLooping);
            }

            public void IsTheDefault()
            {
                CheckFalse(default(Loop).IsLooping);
            }
        }

        public class WholeTests : TestFixture
        {
            public void LoopsFromTheStartToTheEnd()
            {
                CheckTrue(Loop.Whole.IsLooping);
                CheckEqual(TimeSpan.Zero, Loop.Whole.Start);
                CheckFalse(Loop.Whole.End.HasValue);
            }
        }

        public class CtorTests : TestFixture
        {
            public void KeepsTheStartAndTheEnd()
            {
                Loop loop = new Loop(Seconds(1), Seconds(3));

                CheckTrue(loop.IsLooping);
                CheckEqual(Seconds(1), loop.Start);
                CheckEqual(Seconds(3), loop.End.Value);
            }

            public void WithNoEnd_LoopsToTheEndOfTheSound()
            {
                CheckFalse(new Loop(Seconds(1)).End.HasValue);
            }

            public void ANegativeStart_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Loop(Seconds(-1));
            }

            public void AnEndEqualToTheStart_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Loop(Seconds(2), Seconds(2));
            }

            public void AnEndBeforeTheStart_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Loop(Seconds(2), Seconds(1));
            }
        }

        public class EndInTests : TestFixture
        {
            public void WithNoEnd_IsTheEndOfTheSound()
            {
                CheckEqual(Seconds(5), new Loop(Seconds(1)).EndIn(Seconds(5)));
            }

            public void WithAnEnd_IsThatEnd()
            {
                CheckEqual(Seconds(3), new Loop(Seconds(1), Seconds(3)).EndIn(Seconds(5)));
            }
        }

        public class CheckAgainstTests : TestFixture
        {
            public void NoLoop_PassesEvenForASoundWithNothingInIt()
            {
                Loop.None.CheckAgainst(TimeSpan.Zero, "loop");
            }

            public void AWholeLoop_PassesForASoundWithSomethingInIt()
            {
                Loop.Whole.CheckAgainst(Seconds(1), "loop");
            }

            public void AWholeLoop_ThrowsForASoundWithNothingInIt()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Loop.Whole.CheckAgainst(TimeSpan.Zero, "loop");
            }

            public void ARegionInsideTheSound_Passes()
            {
                new Loop(Seconds(1), Seconds(2)).CheckAgainst(Seconds(3), "loop");
            }

            public void ARegionEndingWhereTheSoundEnds_Passes()
            {
                new Loop(Seconds(1), Seconds(3)).CheckAgainst(Seconds(3), "loop");
            }

            public void AnEndPastTheSound_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Loop(Seconds(1), Seconds(4)).CheckAgainst(Seconds(3), "loop");
            }

            public void AStartAtTheEndOfTheSound_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Loop(Seconds(3)).CheckAgainst(Seconds(3), "loop");
            }

            public void AStartPastTheEndOfTheSound_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Loop(Seconds(4)).CheckAgainst(Seconds(3), "loop");
            }
        }
    }
}