using System;

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

        public class CtorTests : UnitTestSharp.TestFixture
        {
            public void AssignsAllFourChannels()
            {
                var color = new LinearSpaceColor(0.1, 0.2, 0.3, 0.4);

                CheckEqual(0.1, color.Red);
                CheckEqual(0.2, color.Green);
                CheckEqual(0.3, color.Blue);
                CheckEqual(0.4, color.Alpha);
            }

            public void WithoutAlpha_IsOpaque()
            {
                CheckEqual(1.0, new LinearSpaceColor(0.1, 0.2, 0.3).Alpha);
            }

            public void ChannelsAboveOne_AreKept()
            {
                CheckEqual(4.0, new LinearSpaceColor(4, 0, 0).Red);
            }

            public void NaNChannel_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new LinearSpaceColor(0, double.NaN, 0);
            }

            public void InfiniteChannel_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new LinearSpaceColor(0, 0, 0, double.PositiveInfinity);
            }
        }

        public class FromColorTests : UnitTestSharp.TestFixture
        {
            public void BlackAndWhite_AreZeroAndOne()
            {
                CheckEqual(new LinearSpaceColor(0, 0, 0), LinearSpaceColor.FromColor(Color.FromArgb(0, 0, 0)));
                CheckEqual(new LinearSpaceColor(1, 1, 1), LinearSpaceColor.FromColor(Color.FromArgb(255, 255, 255)));
            }

            public void AChannelBelowTheKnee_IsDividedBy12Point92()
            {
                CheckEqual(5 / 255.0 / 12.92, LinearSpaceColor.FromColor(Color.FromArgb(5, 0, 0)).Red);
            }

            public void MidGray_IsDarkerInLinearLight()
            {
                LinearSpaceColor gray = LinearSpaceColor.FromColor(Color.FromArgb(128, 128, 128));

                CheckTrue(Math.Abs(gray.Green - 0.21586) < Tolerance);
            }

            public void AlphaIsCarriedOverAsACoverageFraction()
            {
                CheckEqual(128 / 255.0, LinearSpaceColor.FromColor(Color.FromArgb(128, 255, 0, 0)).Alpha);
            }
        }

        public class ToSrgbTests : UnitTestSharp.TestFixture
        {
            public void EncodesTheColorChannelsAndKeepsAlpha()
            {
                double encoded = ColorSpace.LinearToSrgb(0.5);

                CheckEqual(
                    new SrgbColor(encoded, encoded, encoded, 0.25), new LinearSpaceColor(0.5, 0.5, 0.5, 0.25).ToSrgb());
            }

            public void ChannelsOutsideZeroToOne_Clamp()
            {
                CheckEqual(new SrgbColor(1, 0, 1, 1), new LinearSpaceColor(3, -2, 1.5, 2).ToSrgb());
            }
        }

        public class ToColorTests : UnitTestSharp.TestFixture
        {
            public void BlackAndWhite_AreZeroAndTwoFiftyFive()
            {
                CheckEqual(Color.FromArgb(0, 0, 0), new LinearSpaceColor(0, 0, 0).ToColor());
                CheckEqual(Color.FromArgb(255, 255, 255), new LinearSpaceColor(1, 1, 1).ToColor());
            }

            public void HalfLinearLight_IsBrighterWhenEncoded()
            {
                CheckEqual(Color.FromArgb(188, 188, 188), new LinearSpaceColor(0.5, 0.5, 0.5).ToColor());
            }

            public void ChannelsOutsideZeroToOne_Clamp()
            {
                CheckEqual(Color.FromArgb(255, 0, 255), new LinearSpaceColor(3, -2, 1.5).ToColor());
            }

            public void AlphaOutsideZeroToOne_Clamps()
            {
                CheckEqual((byte)255, new LinearSpaceColor(0, 0, 0, 2).ToColor().Alpha);
                CheckEqual((byte)0, new LinearSpaceColor(0, 0, 0, -1).ToColor().Alpha);
            }

            public void AlphaIsEncodedLinearlyNotAsLight()
            {
                CheckEqual((byte)128, new LinearSpaceColor(0, 0, 0, 0.5).ToColor().Alpha);
            }

            public void UndoesFromColor_ForAMidtone()
            {
                Color original = Color.FromArgb(77, 12, 34, 56);

                CheckEqual(original, LinearSpaceColor.FromColor(original).ToColor());
            }
        }

        public class LerpTests : UnitTestSharp.TestFixture
        {
            public void AtZero_IsTheStart()
            {
                var from = new LinearSpaceColor(0.25, 0.5, 0.75, 1);

                CheckEqual(from, LinearSpaceColor.Lerp(from, new LinearSpaceColor(1, 0, 0, 0), 0));
            }

            public void AtOne_IsTheEnd()
            {
                var to = new LinearSpaceColor(1, 0.5, 0.25, 0);

                CheckEqual(to, LinearSpaceColor.Lerp(new LinearSpaceColor(0, 0, 0, 1), to, 1));
            }

            public void BlendsEveryColorChannelLinearly()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(0, 0.5, 1, 1), new LinearSpaceColor(1, 0.5, 0, 1), 0.25);

                CheckEqual(new LinearSpaceColor(0.25, 0.5, 0.75, 1), blended);
            }

            public void AlphaBlendsLinearly_LeavingTheSameColorAlone()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(0.5, 0.25, 0.125, 0.25), new LinearSpaceColor(0.5, 0.25, 0.125, 0.75), 0.25);

                CheckEqual(new LinearSpaceColor(0.5, 0.25, 0.125, 0.375), blended);
            }

            public void ATransparentStart_AddsNoColor()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(0, 0, 0, 0), new LinearSpaceColor(1, 0.5, 0.25, 1), 0.5);

                CheckEqual(new LinearSpaceColor(1, 0.5, 0.25, 0.5), blended);
            }

            public void ATransparentEnd_AddsNoColor()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(1, 0.5, 0.25, 1), new LinearSpaceColor(0, 0, 0, 0), 0.5);

                CheckEqual(new LinearSpaceColor(1, 0.5, 0.25, 0.5), blended);
            }

            public void BothTransparent_BlendTheColorsLinearly()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(0, 0, 0, 0), new LinearSpaceColor(1, 0.5, 0.25, 0), 0.5);

                CheckEqual(new LinearSpaceColor(0.5, 0.25, 0.125, 0), blended);
            }

            public void UnequalAlphas_WeighEachColorByItsAlpha()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(0, 0.5, 1, 0.25), new LinearSpaceColor(1, 0.5, 0, 0.75), 0.5);

                CheckEqual(new LinearSpaceColor(0.75, 0.5, 0.25, 0.5), blended);
            }

            public void ANegativeAlpha_CountsAsTransparent()
            {
                LinearSpaceColor blended = LinearSpaceColor.Lerp(
                    new LinearSpaceColor(0, 0, 0, -1), new LinearSpaceColor(1, 0.5, 0.25, 1), 0.5);

                CheckEqual(new LinearSpaceColor(1, 0.5, 0.25, 0), blended);
            }

            public void BlackToWhiteHalfway_DisplaysAsLightGrayNotMidGray()
            {
                Color halfway = LinearSpaceColor.Lerp(
                    LinearSpaceColor.FromColor(Colors.Black), LinearSpaceColor.FromColor(Colors.White), 0.5).ToColor();

                CheckEqual(Color.FromArgb(188, 188, 188), halfway);
            }

            public void AmountBelowZero_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                LinearSpaceColor.Lerp(new LinearSpaceColor(0, 0, 0), new LinearSpaceColor(1, 1, 1), -0.1);
            }

            public void AmountAboveOne_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                LinearSpaceColor.Lerp(new LinearSpaceColor(0, 0, 0), new LinearSpaceColor(1, 1, 1), 1.1);
            }

            public void NaNAmount_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                LinearSpaceColor.Lerp(new LinearSpaceColor(0, 0, 0), new LinearSpaceColor(1, 1, 1), double.NaN);
            }
        }

        public class EqualityTests : UnitTestSharp.TestFixture
        {
            public void SameChannels_AreEqual()
            {
                CheckTrue(new LinearSpaceColor(0.1, 0.2, 0.3, 0.4).Equals(new LinearSpaceColor(0.1, 0.2, 0.3, 0.4)));
                CheckTrue(new LinearSpaceColor(0.1, 0.2, 0.3, 0.4) == new LinearSpaceColor(0.1, 0.2, 0.3, 0.4));
                CheckFalse(new LinearSpaceColor(0.1, 0.2, 0.3, 0.4) != new LinearSpaceColor(0.1, 0.2, 0.3, 0.4));
            }

            public void AnyDifferentChannel_IsNotEqual()
            {
                var baseColor = new LinearSpaceColor(0.1, 0.2, 0.3, 0.4);

                CheckFalse(baseColor.Equals(new LinearSpaceColor(0.9, 0.2, 0.3, 0.4)));
                CheckFalse(baseColor.Equals(new LinearSpaceColor(0.1, 0.9, 0.3, 0.4)));
                CheckFalse(baseColor.Equals(new LinearSpaceColor(0.1, 0.2, 0.9, 0.4)));
                CheckFalse(baseColor.Equals(new LinearSpaceColor(0.1, 0.2, 0.3, 0.9)));
                CheckTrue(baseColor != new LinearSpaceColor(0.1, 0.2, 0.3, 0.9));
            }

            public void BoxedColor_IsEqualToTheSameColor()
            {
                CheckTrue(new LinearSpaceColor(0.1, 0.2, 0.3).Equals((object)new LinearSpaceColor(0.1, 0.2, 0.3)));
            }

            public void ANonLinearSpaceColor_IsNotEqual()
            {
                CheckFalse(new LinearSpaceColor(0.1, 0.2, 0.3).Equals("color"));
            }

            public void EqualColors_HaveTheSameHashCode()
            {
                CheckEqual(new LinearSpaceColor(0.1, 0.2, 0.3, 0.4).GetHashCode(),
                    new LinearSpaceColor(0.1, 0.2, 0.3, 0.4).GetHashCode());
            }
        }
    }
}