using System;

namespace Prism.UnitTests
{
    public class ColorTests : UnitTestSharp.TestFixture
    {
        public class FromArgbTests : UnitTestSharp.TestFixture
        {
            public void FourChannels_AssignsEachChannel()
            {
                Color color = Color.FromArgb(4, 1, 2, 3);

                CheckEqual((byte)4, color.Alpha);
                CheckEqual((byte)1, color.Red);
                CheckEqual((byte)2, color.Green);
                CheckEqual((byte)3, color.Blue);
            }

            public void ThreeChannels_IsOpaque()
            {
                CheckEqual(Color.FromArgb(255, 10, 20, 30), Color.FromArgb(10, 20, 30));
            }

            public void Packed_UnpacksEachByte()
            {
                Color color = Color.FromArgb(unchecked((int)0x78123456));

                CheckEqual((byte)0x78, color.Alpha);
                CheckEqual((byte)0x12, color.Red);
                CheckEqual((byte)0x34, color.Green);
                CheckEqual((byte)0x56, color.Blue);
            }

            public void Packed_InvertsToArgb()
            {
                CheckEqual(unchecked((int)0xFF804020), Color.FromArgb(unchecked((int)0xFF804020)).ToArgb());
            }

            public void WithAlpha_ReplacesOnlyTheAlpha()
            {
                Color color = Color.FromArgb(7, Color.FromArgb(200, 1, 2, 3));

                CheckEqual(Color.FromArgb(7, 1, 2, 3), color);
            }

            public void ChannelAbove255_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Color.FromArgb(255, 256, 0, 0);
            }

            public void NegativeChannel_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Color.FromArgb(0, -1, 0);
            }

            public void AlphaAbove255_WithABaseColor_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Color.FromArgb(256, Colors.Red);
            }
        }

        public class EqualityTests : UnitTestSharp.TestFixture
        {
            public void SameChannels_AreEqual()
            {
                CheckTrue(Color.FromArgb(1, 2, 3, 4).Equals(Color.FromArgb(1, 2, 3, 4)));
                CheckTrue(Color.FromArgb(1, 2, 3, 4) == Color.FromArgb(1, 2, 3, 4));
                CheckFalse(Color.FromArgb(1, 2, 3, 4) != Color.FromArgb(1, 2, 3, 4));
            }

            public void AnyDifferentChannel_IsNotEqual()
            {
                CheckFalse(Color.FromArgb(1, 2, 3, 4) == Color.FromArgb(9, 2, 3, 4));
                CheckFalse(Color.FromArgb(1, 2, 3, 4) == Color.FromArgb(1, 9, 3, 4));
                CheckFalse(Color.FromArgb(1, 2, 3, 4) == Color.FromArgb(1, 2, 9, 4));
                CheckTrue(Color.FromArgb(1, 2, 3, 4) != Color.FromArgb(1, 2, 3, 9));
            }

            public void BoxedColor_IsEqualToTheSameColor()
            {
                CheckTrue(Color.FromArgb(1, 2, 3, 4).Equals((object)Color.FromArgb(1, 2, 3, 4)));
            }

            public void ANonColor_IsNotEqual()
            {
                CheckFalse(Color.FromArgb(1, 2, 3, 4).Equals("color"));
            }

            public void EqualColors_HaveTheSameHashCode()
            {
                CheckEqual(Color.FromArgb(1, 2, 3, 4).GetHashCode(), Color.FromArgb(1, 2, 3, 4).GetHashCode());
            }
        }

        public class CtorTests : UnitTestSharp.TestFixture
        {
            public void RoundsEachComponentToTheNearestByte()
            {
                CheckEqual(Color.FromArgb(4, 1, 2, 3), new Color(1 / 255.0, 2 / 255.0, 3 / 255.0, 4 / 255.0));
            }

            public void ThreeComponents_IsOpaque()
            {
                CheckEqual((byte)255, new Color(0.0, 0.5, 1.0).Alpha);
            }

            public void ComponentAboveOne_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Color(1.1, 0, 0);
            }

            public void NegativeComponent_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new Color(0, 0, 0, -0.1);
            }

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

        public class ToArgbTests : UnitTestSharp.TestFixture
        {
            public void PacksEachChannelIntoItsOwnByte()
            {
                var color = new Color { Red = 0x12, Green = 0x34, Blue = 0x56, Alpha = 0x78 };
                CheckEqual(0x78123456, color.ToArgb());
            }

            public void FullAlphaSetsTheHighByteAndSignBit()
            {
                var color = new Color { Red = 0, Green = 0, Blue = 0, Alpha = 0xFF };
                CheckEqual(unchecked((int)0xFF000000), color.ToArgb());
            }

            public void OpaqueWhiteIsAllBitsSet()
            {
                CheckEqual(unchecked((int)0xFFFFFFFF), new Color(1, 1, 1).ToArgb());
            }

            public void TransparentIsZero()
            {
                CheckEqual(0, Colors.Transparent.ToArgb());
            }

            public void PacksFractionalColorThroughConstructorRounding()
            {
                CheckEqual(0x00FFBF40, new Color(1, 0.75, 0.25, 0).ToArgb());
            }
        }
    }
}