using System;
using Azimuth;
using Blacklight.Core.Drawables;
using UnitTestSharp;

namespace Blacklight.Core.UnitTests.Drawables
{
    public class FillTransformPropertyTests : TestFixture
    {
        static readonly AffineMatrix Shell = new AffineMatrix(2, 0.5, 5, 0.25, 3, 7);
        static readonly AffineMatrix Inside = new AffineMatrix(1, 0.1, 9, 0, 2, 4);
        static readonly AffineMatrix Singular = new AffineMatrix(1, 2, 0, 2, 4, 0);

        static readonly Vector[] Triangle = { new Vector(0, 0), new Vector(5, 0), new Vector(1, 4) };

        static readonly Vector[] ClosedCurve =
        {
            new Vector(0, 0), new Vector(-5, 0), new Vector(-10, 10),
            new Vector(0, 7), new Vector(10, 10), new Vector(5, -5),
        };

        // Each helper takes the primitive as its interface, so a struct is boxed and the setters write through.
        public class DefaultTests : TestFixture
        {
            [IgnoreTest]
            void CheckDefaultsToTheIdentity(IDrawPrimitive primitive)
            {
                CheckEqual(AffineMatrix.Identity, primitive.ShellFillTransform);
                CheckEqual(AffineMatrix.Identity, primitive.InsideFillTransform);
            }

            public void Rectangle_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new Rectangle());
            }

            public void Ellipse_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new Ellipse());
            }

            public void LineSegment_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new LineSegment());
            }

            public void QuadraticBezierTriangle_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new QuadraticBezierTriangle());
            }

            public void BorderTriangle_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new BorderTriangle());
            }

            public void Polygon_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new Polygon(Triangle));
            }

            public void BorderPolygon_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new BorderPolygon(Triangle));
            }

            public void Polyline_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new Polyline(Triangle));
            }

            public void ClosedQuadraticBezierCurve_IsTheIdentity()
            {
                CheckDefaultsToTheIdentity(new ClosedQuadraticBezierCurve(ClosedCurve));
            }

            public void Sprite_IsTheIdentity()
            {
                CheckEqual(AffineMatrix.Identity, new Sprite().TintTransform);
                CheckEqual(AffineMatrix.Identity, default(Sprite).TintTransform);
            }

            public void ADefaultStruct_IsTheIdentity()
            {
                CheckEqual(AffineMatrix.Identity, default(Rectangle).InsideFillTransform);
            }

            public void ScalingAnUnsetTransform_ScalesTheIdentity()
            {
                var rectangle = new Rectangle();

                rectangle.InsideFillTransform = rectangle.InsideFillTransform * 2;

                CheckEqual(AffineMatrix.Identity * 2, rectangle.InsideFillTransform);
            }
        }

        public class SetTests : TestFixture
        {
            [IgnoreTest]
            void CheckKeepsWhatWasSet(IDrawPrimitive primitive)
            {
                primitive.ShellFillTransform = Shell;
                primitive.InsideFillTransform = Inside;

                CheckEqual(Shell, primitive.ShellFillTransform);
                CheckEqual(Inside, primitive.InsideFillTransform);
            }

            public void Rectangle_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new Rectangle());
            }

            public void Ellipse_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new Ellipse());
            }

            public void LineSegment_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new LineSegment());
            }

            public void QuadraticBezierTriangle_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new QuadraticBezierTriangle());
            }

            public void BorderTriangle_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new BorderTriangle());
            }

            public void Polygon_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new Polygon(Triangle));
            }

            public void BorderPolygon_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new BorderPolygon(Triangle));
            }

            public void Polyline_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new Polyline(Triangle));
            }

            public void ClosedQuadraticBezierCurve_KeepsBothTransforms()
            {
                CheckKeepsWhatWasSet(new ClosedQuadraticBezierCurve(ClosedCurve));
            }

            public void Sprite_KeepsTheTintTransform()
            {
                var sprite = new Sprite { TintTransform = Inside };

                CheckEqual(Inside, sprite.TintTransform);
            }

            public void TheShellAndInsideAreIndependent()
            {
                var rectangle = new Rectangle { InsideFillTransform = Inside };

                CheckEqual(AffineMatrix.Identity, rectangle.ShellFillTransform);
            }
        }

        public class RejectionTests : TestFixture
        {
            [IgnoreTest]
            bool Throws(System.Action action)
            {
                try
                {
                    action();
                }
                catch (ArgumentException)
                {
                    return true;
                }

                return false;
            }

            [IgnoreTest]
            void CheckRejectsASingularMatrix(IDrawPrimitive primitive)
            {
                CheckTrue(Throws(() => primitive.ShellFillTransform = Singular));
                CheckTrue(Throws(() => primitive.InsideFillTransform = Singular));
                CheckEqual(AffineMatrix.Identity, primitive.ShellFillTransform);
                CheckEqual(AffineMatrix.Identity, primitive.InsideFillTransform);
            }

            public void Rectangle_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new Rectangle());
            }

            public void Ellipse_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new Ellipse());
            }

            public void LineSegment_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new LineSegment());
            }

            public void QuadraticBezierTriangle_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new QuadraticBezierTriangle());
            }

            public void BorderTriangle_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new BorderTriangle());
            }

            public void Polygon_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new Polygon(Triangle));
            }

            public void BorderPolygon_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new BorderPolygon(Triangle));
            }

            public void Polyline_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(new Polyline(Triangle));
            }

            public void ClosedQuadraticBezierCurve_RejectsASingularMatrix()
            {
                CheckRejectsASingularMatrix(
                    new ClosedQuadraticBezierCurve(ClosedCurve));
            }

            public void Sprite_RejectsASingularMatrix()
            {
                var sprite = new Sprite();

                CheckThrow(typeof(ArgumentException));
                sprite.TintTransform = Singular;
            }

            public void ATransformSetToTheAllZeroMatrix_IsRejectedNotTreatedAsUnset()
            {
                var rectangle = new Rectangle();

                CheckThrow(typeof(ArgumentException));
                rectangle.InsideFillTransform = default;
            }
        }

        public class CopyFromTests : TestFixture
        {
            public void StructToStruct_CopiesBothTransforms()
            {
                var source = new Rectangle { ShellFillTransform = Shell, InsideFillTransform = Inside };
                var destination = new Rectangle();

                destination.CopyFrom(ref source);

                CheckEqual(Shell, destination.ShellFillTransform);
                CheckEqual(Inside, destination.InsideFillTransform);
            }

            public void ClassToStruct_CopiesBothTransforms()
            {
                var source = new Polygon(Triangle) { ShellFillTransform = Shell, InsideFillTransform = Inside };
                var destination = new Rectangle();

                destination.CopyFrom(source);

                CheckEqual(Shell, destination.ShellFillTransform);
                CheckEqual(Inside, destination.InsideFillTransform);
            }

            public void ClassToClass_CopiesBothTransforms()
            {
                var source = new Polygon(Triangle) { ShellFillTransform = Shell, InsideFillTransform = Inside };
                var destination = new BorderPolygon(Triangle);

                destination.CopyFrom(source);

                CheckEqual(Shell, destination.ShellFillTransform);
                CheckEqual(Inside, destination.InsideFillTransform);
            }

            public void AnUnsetSource_LeavesTheDestinationAtTheIdentity()
            {
                var source = new Rectangle();
                var destination = new Rectangle { ShellFillTransform = Shell, InsideFillTransform = Inside };

                destination.CopyFrom(ref source);

                CheckEqual(AffineMatrix.Identity, destination.ShellFillTransform);
                CheckEqual(AffineMatrix.Identity, destination.InsideFillTransform);
            }
        }
    }
}