using System;

namespace Prism.UnitTests
{
    public class HuesTests : UnitTestSharp.TestFixture
    {
        private const double Tolerance = 1e-12;

        public class FromColorTests : UnitTestSharp.TestFixture
        {
            public void Red_IsZero()
            {
                CheckEqual(0.0, Hues.FromColor(Color.FromArgb(255, 0, 0)));
            }

            public void Yellow_IsASixth()
            {
                CheckEqual(1 / 6.0, Hues.FromColor(Color.FromArgb(255, 255, 0)));
            }

            public void Green_IsAThird()
            {
                CheckEqual(2 / 6.0, Hues.FromColor(Color.FromArgb(0, 255, 0)));
            }

            public void Cyan_IsAHalf()
            {
                CheckEqual(3 / 6.0, Hues.FromColor(Color.FromArgb(0, 255, 255)));
            }

            public void Blue_IsTwoThirds()
            {
                CheckEqual(4 / 6.0, Hues.FromColor(Color.FromArgb(0, 0, 255)));
            }

            public void Magenta_IsFiveSixths()
            {
                CheckTrue(Math.Abs(5 / 6.0 - Hues.FromColor(Color.FromArgb(255, 0, 255))) < Tolerance);
            }

            public void Orange_IsBetweenRedAndYellow()
            {
                CheckTrue(Math.Abs(128 / 255.0 / 6 - Hues.FromColor(Color.FromArgb(255, 128, 0))) < Tolerance);
            }

            public void Gray_IsZero()
            {
                CheckEqual(0.0, Hues.FromColor(Color.FromArgb(128, 128, 128)));
            }

            public void IgnoresAlpha()
            {
                CheckEqual(0.0, Hues.FromColor(Color.FromArgb(10, 255, 0, 0)));
            }
        }

        public class WrapTests : UnitTestSharp.TestFixture
        {
            public void AHueInRange_IsUnchanged()
            {
                CheckEqual(0.25, Hues.Wrap(0.25));
            }

            public void Zero_IsZero()
            {
                CheckEqual(0.0, Hues.Wrap(0));
            }

            public void AboveOne_WrapsAround()
            {
                CheckEqual(0.25, Hues.Wrap(1.25));
            }

            public void Negative_WrapsForwards()
            {
                CheckEqual(0.75, Hues.Wrap(-0.25));
            }

            public void ExactlyOne_WrapsToZero()
            {
                CheckEqual(0.0, Hues.Wrap(1));
            }

            public void TooSmallToLeaveZero_StaysZero()
            {
                CheckEqual(0.0, Hues.Wrap(-1e-20));
            }

            public void NaN_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Hues.Wrap(double.NaN);
            }

            public void Infinity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Hues.Wrap(double.PositiveInfinity);
            }
        }

        public class TravelTests : UnitTestSharp.TestFixture
        {
            public void Shortest_GoingUp_WithoutWrapping()
            {
                CheckEqual(0.25, Hues.Travel(0.25, 0.5, HueDirection.Shortest));
            }

            public void Shortest_GoingDown_WithoutWrapping()
            {
                CheckEqual(-0.25, Hues.Travel(0.5, 0.25, HueDirection.Shortest));
            }

            public void Shortest_WrappingUpPastOne()
            {
                CheckEqual(0.25, Hues.Travel(0.875, 0.125, HueDirection.Shortest));
            }

            public void Shortest_WrappingDownPastZero()
            {
                CheckEqual(-0.25, Hues.Travel(0.125, 0.875, HueDirection.Shortest));
            }

            public void Shortest_OppositeHues_GoUp()
            {
                CheckEqual(0.5, Hues.Travel(0, 0.5, HueDirection.Shortest));
                CheckEqual(0.5, Hues.Travel(0.5, 0, HueDirection.Shortest));
            }

            public void Longest_GoingUpTheShortWay_GoesDownInstead()
            {
                CheckEqual(-0.75, Hues.Travel(0.25, 0.5, HueDirection.Longest));
            }

            public void Longest_GoingDownTheShortWay_GoesUpInstead()
            {
                CheckEqual(0.75, Hues.Travel(0.5, 0.25, HueDirection.Longest));
            }

            public void Longest_WrappingTheShortWay_GoesTheOtherWayRound()
            {
                CheckEqual(0.75, Hues.Travel(0.125, 0.875, HueDirection.Longest));
            }

            public void Longest_OppositeHues_GoUp()
            {
                CheckEqual(0.5, Hues.Travel(0, 0.5, HueDirection.Longest));
                CheckEqual(0.5, Hues.Travel(0.5, 0, HueDirection.Longest));
            }

            public void Longest_EqualHues_DontMove()
            {
                CheckEqual(0.0, Hues.Travel(0.25, 0.25, HueDirection.Longest));
            }

            public void Increasing_ToAHigherHue_GoesDirectly()
            {
                CheckEqual(0.25, Hues.Travel(0.25, 0.5, HueDirection.Increasing));
            }

            public void Increasing_ToALowerHue_WrapsPastOne()
            {
                CheckEqual(0.5, Hues.Travel(0.75, 0.25, HueDirection.Increasing));
            }

            public void Increasing_EqualHues_DontMove()
            {
                CheckEqual(0.0, Hues.Travel(0.25, 0.25, HueDirection.Increasing));
            }

            public void Decreasing_ToALowerHue_GoesDirectly()
            {
                CheckEqual(-0.25, Hues.Travel(0.5, 0.25, HueDirection.Decreasing));
            }

            public void Decreasing_ToAHigherHue_WrapsPastZero()
            {
                CheckEqual(-0.5, Hues.Travel(0.25, 0.75, HueDirection.Decreasing));
            }

            public void Decreasing_EqualHues_DontMove()
            {
                CheckEqual(0.0, Hues.Travel(0.25, 0.25, HueDirection.Decreasing));
            }

            public void AnUnknownDirection_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Hues.Travel(0, 0.5, (HueDirection)99);
            }
        }

        public class BlendTests : UnitTestSharp.TestFixture
        {
            public void BothShowingAHue_MoveAlongTheTravel()
            {
                CheckEqual(0.0, Hues.Blend(0.875, true, 0.125, true, 0.5, HueDirection.Shortest));
            }

            public void BothShowingAHue_AtZero_StayAtTheStart()
            {
                CheckEqual(0.25, Hues.Blend(0.25, true, 0.5, true, 0, HueDirection.Shortest));
            }

            public void AStartShowingNoHue_TakesTheEnds()
            {
                CheckEqual(0.5, Hues.Blend(0.25, false, 0.5, true, 0.5, HueDirection.Shortest));
            }

            public void AnEndShowingNoHue_KeepsTheStarts()
            {
                CheckEqual(0.25, Hues.Blend(0.25, true, 0.5, false, 0.5, HueDirection.Shortest));
            }

            public void NeitherShowingAHue_KeepsTheStarts()
            {
                CheckEqual(0.25, Hues.Blend(0.25, false, 0.5, false, 0.5, HueDirection.Shortest));
            }
        }
    }
}