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

namespace Blacklight.Core.UnitTests
{
    public class SoftwareCursorTests : UnitTestSharp.TestFixture
    {
        /// <summary>
        /// A real sprite source, minus the texture nothing here draws with.
        /// </summary>
        public static ISpriteSource Art(int width = 16, int height = 16)
        {
            return new SpriteSheet { SpriteSize = new Size(width, height) }.Frame(Point.Empty);
        }

        public static SoftwareCursor Cursor(ISpriteSource art)
        {
            return new SoftwareCursor { Source = art, Visible = true };
        }

        public static SpriteDestination Destination(SoftwareCursor cursor)
        {
            return cursor.Drawable().Destination(cursor.Source);
        }

        public class DrawingTests : UnitTestSharp.TestFixture
        {
            public void VisibleWithArt_IsTrue()
            {
                CheckTrue(Cursor(Art()).Drawing);
            }

            public void Hidden_IsFalse()
            {
                SoftwareCursor cursor = Cursor(Art());
                cursor.Visible = false;

                CheckFalse(cursor.Drawing);
            }

            public void VisibleWithoutArt_IsFalse()
            {
                CheckFalse(new SoftwareCursor { Visible = true }.Drawing);
            }

            public void DefaultsToNotDrawing()
            {
                CheckFalse(new SoftwareCursor().Drawing);
            }
        }

        public class DrawableTests : UnitTestSharp.TestFixture
        {
            public void CarriesTheArtThrough()
            {
                ISpriteSource art = Art();

                CheckEqual(art, Cursor(art).Drawable().Source);
            }

            public void NoHotspotAtScaleOne_SpansTheArtFromTheOrigin()
            {
                SpriteDestination destination = Destination(Cursor(Art(16, 8)));

                CheckEqual(Vector.Zero, destination.min);
                CheckEqual(new Vector(16, 8), destination.max);
            }

            public void Hotspot_ShiftsTheArtSoTheHotspotSitsAtTheOrigin()
            {
                SoftwareCursor cursor = Cursor(Art(16, 16));
                cursor.Hotspot = new Vector(4, 6);

                SpriteDestination destination = Destination(cursor);

                CheckEqual(new Vector(-4, -6), destination.min);
                CheckEqual(new Vector(12, 10), destination.max);
            }

            public void Scale_GrowsTheArtAboutTheHotspot()
            {
                SoftwareCursor cursor = Cursor(Art(16, 16));
                cursor.Hotspot = new Vector(4, 6);
                cursor.Scale = 3;

                SpriteDestination destination = Destination(cursor);

                CheckEqual(new Vector(-12, -18), destination.min);
                CheckEqual(new Vector(36, 30), destination.max);
            }

            public void PositionIsNotBakedIn_SoItRidesTheEntityTransform()
            {
                SoftwareCursor cursor = Cursor(Art(16, 16));
                SpriteDestination before = Destination(cursor);

                cursor.Position = new Vector(400, 300);
                SpriteDestination after = Destination(cursor);

                CheckEqual(before.min, after.min);
                CheckEqual(before.max, after.max);
            }

            public void CalledTwice_ReturnsTheSameSprite()
            {
                SoftwareCursor cursor = Cursor(Art());

                CheckEqual(cursor.Drawable(), cursor.Drawable());
            }

            public void AfterOnlyMoving_ReturnsTheSameSprite()
            {
                SoftwareCursor cursor = Cursor(Art());
                Sprite first = cursor.Drawable();

                cursor.Position = new Vector(12, 34);

                CheckEqual(first, cursor.Drawable());
            }

            public void AfterTheArtChanges_RebuildsTheSprite()
            {
                SoftwareCursor cursor = Cursor(Art());
                Sprite first = cursor.Drawable();

                cursor.Source = Art();

                CheckNotEqual(first, cursor.Drawable());
            }

            public void AfterTheHotspotChanges_RebuildsTheSprite()
            {
                SoftwareCursor cursor = Cursor(Art());
                Sprite first = cursor.Drawable();

                cursor.Hotspot = new Vector(1, 1);

                CheckNotEqual(first, cursor.Drawable());
            }

            public void AfterTheScaleChanges_RebuildsTheSprite()
            {
                SoftwareCursor cursor = Cursor(Art());
                Sprite first = cursor.Drawable();

                cursor.Scale = 2;

                CheckNotEqual(first, cursor.Drawable());
            }
        }
    }
}