using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnitTestSharp;
using Azimuth;

namespace Glass.UnitTests
{
    public class RectTests : TestFixture
    {
        public void CornerTests()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));

            CheckEqual(new Vector(-3, -4), rect.TopLeft);
            CheckEqual(new Vector(5, -4), rect.TopRight);
            CheckEqual(new Vector(-3, 6), rect.BottomLeft);
            CheckEqual(new Vector(5, 6), rect.BottomRight);
            CheckEqual(new Vector(1, 1), rect.Center);
        }

        public void EdgeTests()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));

            CheckEqual(-3, rect.Left);
            CheckEqual(5, rect.Right);
            CheckEqual(6, rect.Bottom);
            CheckEqual(-4, rect.Top);
        }

        public void WidthHeight()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));

            CheckEqual(8, rect.Width);
            CheckEqual(10, rect.Height);
        }

        public void PositionAndSize()
        {
            var rect = Rect.FromPositionAndSize(new Vector(100, 50), new Vector(3, 4));

            CheckEqual(new Vector(100, 50), rect.Position);
            CheckEqual(new Vector(3, 4), rect.Size);
        }

        public void Zero()
        {
            CheckEqual(Rect.FromPositionAndSize(Vector.Zero, Vector.Zero), Rect.Zero);
        }

        public class SplitHorizontally : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(25);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -5));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, -5), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void MarginIsTakenFromBottomHalf()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(25, margin: 10);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -5));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, 5), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void NegativeMarginCausesOverlap()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(25, margin: -10);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -5));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, -15), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void NegativeSplitHeightThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitHorizontally(-1);
            }

            public void TooLargeSplitHeightThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitHorizontally(81);
            }

            public void SplitHeight_0()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(0);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -30));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void SplitHeight_Height()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(80);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, 50), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void MarginGreaterThanHeight()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitHorizontally(70, 11);
            }
        }

        public class SplitVertically : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(10);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-10, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void MarginIsTakenFromRightHalf()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(10, margin: 5);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-5, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void NegativeMarginCausesOverlap()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(10, margin: -5);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-15, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void NegativeSplitWidthThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitVertically(-1);
            }

            public void TooLargeSplitWidthThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitVertically(31);
            }

            public void SplitWidth_0()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(0);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-20, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void SplitWidth_Width()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(30);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(10, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void MarginGreaterThanHeight()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitVertically(20, 11);
            }
        }

        public class NewRow : TestFixture
        {
            public void TopJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(5);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 5)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 9), new Vector(5, 1)), rect);
            }

            public void BottomJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(5, VerticalJustification.Bottom);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 1)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 5), new Vector(5, 5)), row);
            }

            public void TopJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(4, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 4)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 9), new Vector(5, 1)), rect);
            }

            public void BottomJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(4, VerticalJustification.Bottom, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 1)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 6), new Vector(5, 4)), row);
            }

            public void HeightLargerThanRectHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.NewRow(7);
            }
        }

        public class NewCol : TestFixture
        {
            public void LeftJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(4);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(4, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(7, 4), new Vector(1, 6)), rect);
            }

            public void LeftJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(3, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(3, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(7, 4), new Vector(1, 6)), rect);
            }

            public void RightJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(4, HorizontalJustification.Right);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(1, 6)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(4, 4), new Vector(4, 6)), row);
            }

            public void RightJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(3, HorizontalJustification.Right, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(1, 6)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(5, 4), new Vector(3, 6)), row);
            }

            public void WidthGreaterThanWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                var row = rect.NewCol(6);
            }
        }

        public class FromPositionAndSizeTests : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckEqual(new Vector(3, 4), rect.Position);
                CheckEqual(new Vector(5, 6), rect.Size);
            }

            public void Zero()
            {
                var rect = Rect.FromPositionAndSize(Vector.Zero, Vector.Zero);
                CheckEqual(Vector.Zero, rect.Position);
                CheckEqual(Vector.Zero, rect.Size);
            }
        }

        public class FromTwoPointsTests : TestFixture
        {
            public void TopLeftAndBottomRight()
            {
                var rect = Rect.FromTwoPoints(new Vector(3, 4), new Vector(5, 6));
                CheckEqual(new Vector(3, 4), rect.TopLeft);
                CheckEqual(new Vector(5, 6), rect.BottomRight);
            }

            public void TopRightAndBottomLeft()
            {
                var rect = Rect.FromTwoPoints(new Vector(5, 4), new Vector(3, 6));
                CheckEqual(new Vector(3, 4), rect.TopLeft);
                CheckEqual(new Vector(5, 6), rect.BottomRight);
            }

            public void SamePoint()
            {
                var rect = Rect.FromTwoPoints(Vector.Zero, Vector.Zero);
                CheckEqual(new Rect(), rect);
            }
        }

        public class ContainsPoint : TestFixture
        {
            public void Inside()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(Vector.Zero));
            }

            public void OnLeftEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(-10, 0)));
            }

            public void OnRightEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(3, 0)));
            }

            public void OnTopEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(0, -5)));
            }

            public void OnBottomEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(0, 4)));
            }

            public void OnTopLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(-10, -5)));
            }

            public void OnTopRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(3, -5)));
            }

            public void OnBottomRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(3, 4)));
            }

            public void OnBottomLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(-10, 4)));
            }

            public void OutsideTopLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(-11, -6)));
            }

            public void OutsideTopRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(4, -6)));
            }

            public void OutsideBottomRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(4, 5)));
            }

            public void OutsideBottomLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(-11, 5)));
            }

            public void OutsideLeftEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(-11, 0)));
            }

            public void OutsideRightEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(4, 0)));
            }

            public void OutsideTopEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(0, -6)));
            }

            public void OutsideBottomEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(0, 5)));
            }
        }

        public class ToStringTests : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckEqual("<3 : 4>, <5 : 6>", rect.ToString());
            }
        }

        public class ToGraphicsAffineMatrixTests : TestFixture
        {
            public void TransformsCorners()
            {
                var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));
                var matrix = rect.ToGraphicsAffineMatrix();
                CheckEqual(new Vector(-3, -6), matrix.TransformPoint(new Vector(-1, -1)));
                CheckEqual(new Vector(5, -6), matrix.TransformPoint(new Vector(1, -1)));
                CheckEqual(new Vector(-3, 4), matrix.TransformPoint(new Vector(-1, 1)));
                CheckEqual(new Vector(5, 4), matrix.TransformPoint(new Vector(1, 1)));
            }
        }
    }
}