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

namespace Glass.UnitTests
{
    public class ThreeTallMaterialTests : TestFixture
    {
        Material childMaterial0;
        Material childMaterial1;
        Material childMaterial2;
        ThreeTallMaterial material;

        public override void FixtureSetup()
        {
            childMaterial0 = new Material();
            childMaterial1 = new Material();
            childMaterial2 = new Material();

            material = new ThreeTallMaterial
            {
                ChildMaterials = new[] { childMaterial0, childMaterial1, childMaterial2 },
            };
        }

        public void MaterialsArray()
        {
            CheckEqual(material.ChildMaterials[0], childMaterial0);
            CheckEqual(material.ChildMaterials[1], childMaterial1);
            CheckEqual(material.ChildMaterials[2], childMaterial2);
        }

        public void ChildMaterialAttributes()
        {
            CheckEqual(material.TopMaterial, childMaterial0);
            CheckEqual(material.CenterMaterial, childMaterial1);
            CheckEqual(material.BottomMaterial, childMaterial2);
        }

        public void ChildMaterials()
        {
            var expected = new [] { childMaterial0, childMaterial1, childMaterial2 };
            CheckEqual(expected, material.ChildMaterials);
        }

        public void WithLeavesTheOriginalUntouched()
        {
            ThreeTallMaterial original = material with { TintColor = Color.Red };
            ThreeTallMaterial copy = original with { TintColor = Color.AliceBlue };

            CheckEqual(Color.Red, original.TintColor);
            CheckEqual(Color.AliceBlue, copy.TintColor);
        }

        public void WithKeepsTheSameChildMaterials()
        {
            ThreeTallMaterial copy = material with { TintColor = Color.Red };

            CheckEqual(material.ChildMaterials, copy.ChildMaterials);
        }

        public static readonly Rect.BorderSize Border =
            new Rect.BorderSize { Left = 3, Right = 2, Top = 2, Bottom = 2 };

        public static Rect RectAt(Scalar x, Scalar y, Scalar width, Scalar height)
        {
            return Rect.FromPositionAndSize(new Vector(x, y), new Vector(width, height));
        }

        public static ThreeTallMaterial WithoutAspectLockedCaps(ThreeTallMaterial material)
        {
            Material[] cells = material.ChildMaterials.ToArray();
            cells[0] = ((SpriteMaterial)cells[0]) with { LockAspectRatio = false };
            cells[2] = ((SpriteMaterial)cells[2]) with { LockAspectRatio = false };
            return material with { ChildMaterials = cells };
        }

        public static ThreeTallMaterial WithSprites(int spriteWidth, int spriteHeight)
        {
            return SpriteMaterial.CreateThreeTall(
                new SpriteSheetAttribute(spriteWidth, spriteHeight, borderSize: 0, "test"),
                new Glass.Point(3, 4));
        }

        public static ThreeTallMaterial WithSprites(int spriteWidth, int spriteHeight, Rect.BorderSize border)
        {
            return SpriteMaterial.CreateThreeTall(
                new SpriteSheetAttribute(spriteWidth, spriteHeight, borderSize: 0, "test"),
                new Glass.Point(3, 4), border);
        }

        public static ThreeTallMaterial WithFillingChildren(Rect.BorderSize border)
        {
            return new ThreeTallMaterial
            {
                BorderSize = border,
                ChildMaterials = new[] { new Material(), new Material(), new Material() },
            };
        }

        public class MeasureTests : TestFixture
        {
            public void SumsTheChildHeightsAndTakesTheWidestChild()
            {
                CheckEqual(new Vector(20, 30), WithSprites(20, 10).Measure(Constraints.Unbounded));
            }

            public void NoChildMaterials_MeasuresZero()
            {
                CheckEqual(Vector.Zero, new ThreeTallMaterial().Measure(Constraints.Unbounded));
            }

            public void ClampsToTheOfferedSpace()
            {
                CheckEqual(new Vector(5, 8), WithSprites(20, 10).Measure(Constraints.Loose(new Vector(5, 8))));
            }
        }

        public class ArrangeTests : TestFixture
        {
            public void CapsTakeTheirSpriteHeightAndTheCenterAbsorbsTheRest()
            {
                ThreeTallMaterial.Rects rects = WithSprites(10, 10).Arrange(RectAt(100, 200, 10, 100));

                CheckEqual(RectAt(100, 200, 10, 10), rects.Top);
                CheckEqual(RectAt(100, 210, 10, 80), rects.Center);
                CheckEqual(RectAt(100, 290, 10, 10), rects.Bottom);
            }

            public void CapNarrowerThanTheRectGrowsTallerToKeepItsAspect()
            {
                ThreeTallMaterial.Rects rects = WithSprites(5, 10).Arrange(RectAt(100, 200, 10, 100));

                CheckEqual(RectAt(100, 200, 10, 20), rects.Top);
                CheckEqual(RectAt(100, 220, 10, 60), rects.Center);
                CheckEqual(RectAt(100, 280, 10, 20), rects.Bottom);
            }

            public void CapWiderThanTheRectShrinksToKeepItsAspect()
            {
                ThreeTallMaterial.Rects rects = WithSprites(20, 10).Arrange(RectAt(100, 200, 10, 100));

                CheckEqual(RectAt(100, 200, 10, 5), rects.Top);
                CheckEqual(RectAt(100, 205, 10, 90), rects.Center);
                CheckEqual(RectAt(100, 295, 10, 5), rects.Bottom);
            }

            public void WithoutAspectLockACapKeepsItsNaturalHeight()
            {
                ThreeTallMaterial threeTall = WithoutAspectLockedCaps(WithSprites(5, 10));

                ThreeTallMaterial.Rects rects = threeTall.Arrange(RectAt(100, 200, 10, 100));

                CheckEqual(RectAt(100, 200, 10, 10), rects.Top);
                CheckEqual(RectAt(100, 210, 10, 80), rects.Center);
                CheckEqual(RectAt(100, 290, 10, 10), rects.Bottom);
            }

            public void CapsWithNoSpriteSheetTakeNoHeight()
            {
                var threeTall = SpriteMaterial.CreateThreeTall(spriteSheet: null, new Glass.Point(3, 4));

                ThreeTallMaterial.Rects rects = threeTall.Arrange(RectAt(100, 200, 10, 100));

                CheckEqual((Scalar)0, rects.Top.Height);
                CheckEqual((Scalar)0, rects.Bottom.Height);
                CheckEqual(RectAt(100, 200, 10, 100), rects.Center);
            }

            public void CenterIsSqueezedOutFirst()
            {
                ThreeTallMaterial.Rects rects = WithSprites(10, 10).Arrange(RectAt(100, 200, 10, 20));

                CheckEqual(RectAt(100, 200, 10, 10), rects.Top);
                CheckEqual((Scalar)0, rects.Center.Height);
                CheckEqual(RectAt(100, 210, 10, 10), rects.Bottom);
            }

            public void BottomCapTruncatesOnceTheCenterIsGone()
            {
                ThreeTallMaterial.Rects rects = WithSprites(10, 10).Arrange(RectAt(100, 200, 10, 15));

                CheckEqual(RectAt(100, 200, 10, 10), rects.Top);
                CheckEqual((Scalar)0, rects.Center.Height);
                CheckEqual(RectAt(100, 210, 10, 5), rects.Bottom);
            }

            public void TopCapTruncatesLast()
            {
                ThreeTallMaterial.Rects rects = WithSprites(10, 10).Arrange(RectAt(100, 200, 10, 5));

                CheckEqual(RectAt(100, 200, 10, 5), rects.Top);
                CheckEqual((Scalar)0, rects.Center.Height);
                CheckEqual((Scalar)0, rects.Bottom.Height);
            }
        }

        public class NaturalWidthTests : TestFixture
        {
            public void Sprites_IsTheSpriteWidth()
            {
                CheckEqual((Scalar)20, WithSprites(20, 10).NaturalWidth);
            }

            public void ChildrenThatOnlyFill_IsNull()
            {
                CheckNull(WithFillingChildren(Border).NaturalWidth);
            }

            public void NoChildMaterials_IsNull()
            {
                CheckNull(new ThreeTallMaterial().NaturalWidth);
            }
        }

        public class ClientRectTests : TestFixture
        {
            public void ArtSizedControl_ErodesByTheBorderItself()
            {
                Rect clientRect = WithSprites(16, 16, Border).ClientRect(RectAt(100, 200, 16, 80));

                CheckEqual(RectAt(103, 202, 11, 76), clientRect);
            }

            public void WiderControl_ThickensTheBorderInStepWithTheArt()
            {
                Rect clientRect = WithSprites(16, 16, Border).ClientRect(RectAt(100, 200, 32, 80));

                CheckEqual(RectAt(106, 204, 22, 72), clientRect);
            }

            public void NarrowerControl_ThinsTheBorder()
            {
                Rect clientRect = WithSprites(16, 16, Border).ClientRect(RectAt(100, 200, 8, 80));

                CheckEqual(RectAt(101.5, 201, 5.5, 78), clientRect);
            }

            public void Scale_LeavesTheBorderAlone()
            {
                ThreeTallMaterial material = WithSprites(16, 16, Border) with { Scale = 2 };

                CheckEqual(RectAt(103, 202, 11, 76), material.ClientRect(RectAt(100, 200, 16, 80)));
            }

            public void ChildrenThatOnlyFill_ErodesByTheBorderUnscaled()
            {
                Rect clientRect = WithFillingChildren(Border).ClientRect(RectAt(100, 200, 32, 80));

                CheckEqual(RectAt(103, 202, 27, 76), clientRect);
            }

            public void NoBorder_ReturnsTheBoundsUnchanged()
            {
                Rect bounds = RectAt(100, 200, 32, 80);

                CheckEqual(bounds, WithSprites(16, 16).ClientRect(bounds));
            }
        }

        public class BoundsForTests : TestFixture
        {
            public void ArtSizedClient_ExpandsByTheBorderItself()
            {
                Rect bounds = WithSprites(16, 16, Border).BoundsFor(RectAt(103, 202, 11, 76));

                CheckEqual(RectAt(100, 200, 16, 80), bounds);
            }

            public void WiderClient_ThickensTheBorderInStepWithTheArt()
            {
                Rect bounds = WithSprites(16, 16, Border).BoundsFor(RectAt(106, 204, 22, 72));

                CheckEqual(RectAt(100, 200, 32, 80), bounds);
            }

            public void Scale_LeavesTheBorderAlone()
            {
                ThreeTallMaterial material = WithSprites(16, 16, Border) with { Scale = 2 };

                CheckEqual(RectAt(100, 200, 16, 80), material.BoundsFor(RectAt(103, 202, 11, 76)));
            }

            public void ChildrenThatOnlyFill_ExpandsByTheBorderUnscaled()
            {
                Rect bounds = WithFillingChildren(Border).BoundsFor(RectAt(103, 202, 27, 76));

                CheckEqual(RectAt(100, 200, 32, 80), bounds);
            }

            public void BorderWiderThanTheArt_ExpandsByTheBorderUnscaled()
            {
                var border = new Rect.BorderSize { Left = 10, Right = 10, Top = 2, Bottom = 2 };

                Rect bounds = WithSprites(16, 16, border).BoundsFor(RectAt(210, 102, 11, 76));

                CheckEqual(RectAt(200, 100, 31, 80), bounds);
            }

            public void InvertsClientRect()
            {
                Rect bounds = RectAt(100, 200, 37, 80);
                ThreeTallMaterial material = WithSprites(16, 16, Border);

                CheckEqual(bounds, material.BoundsFor(material.ClientRect(bounds)));
            }
        }
    }
}