using System;
using System.Drawing;
using System.IO;

namespace Blacklight.Core.UnitTests
{
    public class DecodedImageTests : UnitTestSharp.TestFixture
    {
        public class CtorTests : UnitTestSharp.TestFixture
        {
            public void AssignsPixelsAndSize()
            {
                byte[] pixels = CursorImageTests.Pixels(CursorImageTests.Red, CursorImageTests.Green);

                var image = new DecodedImage(pixels, new Size(2, 1));

                CheckEqual(pixels, image.Rgba);
                CheckEqual(new Size(2, 1), image.Size);
                CheckEqual(2, image.Width);
                CheckEqual(1, image.Height);
            }

            public void NullPixels_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new DecodedImage(null, new Size(1, 1));
            }

            public void ZeroWidth_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new DecodedImage(Array.Empty<byte>(), new Size(0, 1));
            }

            public void ZeroHeight_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new DecodedImage(Array.Empty<byte>(), new Size(1, 0));
            }

            public void PixelCountDisagreeingWithTheSize_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new DecodedImage(CursorImageTests.Pixels(CursorImageTests.Red), new Size(2, 1));
            }

            public void DefaultsToStraightAlpha()
            {
                var image = new DecodedImage(new byte[4], new Size(1, 1));

                CheckEqual(DecodedImage.AlphaMode.Straight, image.Alpha);
            }

            public void KeepsTheGivenAlphaMode()
            {
                var image = new DecodedImage(new byte[4], new Size(1, 1), DecodedImage.AlphaMode.Premultiplied);

                CheckEqual(DecodedImage.AlphaMode.Premultiplied, image.Alpha);
            }

            public void DefaultsToSrgb()
            {
                var image = new DecodedImage(new byte[4], new Size(1, 1));

                CheckFalse(image.IsLinear);
            }

            public void KeepsTheGivenLinearFlag()
            {
                var image = new DecodedImage(new byte[4], new Size(1, 1), isLinear: true);

                CheckTrue(image.IsLinear);
            }
        }

        public class FromStreamTests : UnitTestSharp.TestFixture
        {
            public void DecodesToStraightRgbaInReadingOrder()
            {
                var image = DecodedImage.FromStream(new MemoryStream(CursorImageTests.TwoByTwoPng));

                CheckEqual(new Size(2, 2), image.Size);
                CheckEqual(
                    CursorImageTests.Pixels(
                        CursorImageTests.Red, CursorImageTests.Green,
                        CursorImageTests.Blue, CursorImageTests.Clear),
                    image.Rgba);
            }

            public void NullStream_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                DecodedImage.FromStream(null);
            }

            public void TagsTheResultAsStraightAlpha()
            {
                var image = DecodedImage.FromStream(new MemoryStream(CursorImageTests.TwoByTwoPng));

                CheckEqual(DecodedImage.AlphaMode.Straight, image.Alpha);
            }

            public void HonorsAnExplicitPremultipliedAlphaMode()
            {
                var image = DecodedImage.FromStream(
                    new MemoryStream(CursorImageTests.TwoByTwoPng), DecodedImage.AlphaMode.Premultiplied);

                CheckEqual(DecodedImage.AlphaMode.Premultiplied, image.Alpha);
            }

            public void DefaultsToSrgb()
            {
                var image = DecodedImage.FromStream(new MemoryStream(CursorImageTests.TwoByTwoPng));

                CheckFalse(image.IsLinear);
            }

            public void HonorsAnExplicitLinearFlag()
            {
                var image = DecodedImage.FromStream(
                    new MemoryStream(CursorImageTests.TwoByTwoPng), isLinear: true);

                CheckTrue(image.IsLinear);
            }
        }
    }
}