using Azimuth;
using Blacklight.Core.Cameras;
using UnitTestSharp;

namespace Blacklight.Core.UnitTests.Cameras
{
    public class ViewportTests : TestFixture
    {
        public class RecordingViewport : Viewport
        {
            public int DrawSurfaceWidth { get; private set; }
            public int DrawSurfaceHeight { get; private set; }
            public int DrawSurfaceDeltaPosX { get; private set; }
            public int DrawSurfaceDeltaPosY { get; private set; }
            public int ResizeCount { get; private set; }

            public RecordingViewport(int width, int height) : base(width, height) { }

            protected override void ResizeDrawSurface(int width, int height, int deltaPosX, int deltaPosY)
            {
                DrawSurfaceWidth = width;
                DrawSurfaceHeight = height;
                DrawSurfaceDeltaPosX = deltaPosX;
                DrawSurfaceDeltaPosY = deltaPosY;
                ++ResizeCount;
            }
        }

        public class CtorTests : TestFixture
        {
            public void Always_KeepsTheSizeItWasGiven()
            {
                var viewport = new Viewport(800, 600);

                CheckEqual(800, viewport.Width);
                CheckEqual(600, viewport.Height);
            }

            public void ZeroSize_ClampsToOnePixel()
            {
                var viewport = new Viewport(0, 0);

                CheckEqual(1, viewport.Width);
                CheckEqual(1, viewport.Height);
            }

            public void Always_LeavesTheDrawSurfaceAlone()
            {
                var viewport = new RecordingViewport(800, 600);

                CheckEqual(0, viewport.ResizeCount);
            }
        }

        public class ResizeTests : TestFixture
        {
            public void Always_TakesTheNewSize()
            {
                var viewport = new RecordingViewport(800, 600);
                viewport.Resize(300, 400);

                CheckEqual(300, viewport.Width);
                CheckEqual(400, viewport.Height);
            }

            public void Always_HandsTheDrawSurfaceTheSameSizeAndTheDelta()
            {
                var viewport = new RecordingViewport(800, 600);
                viewport.Resize(300, 400, 7, -9);

                CheckEqual(300, viewport.DrawSurfaceWidth);
                CheckEqual(400, viewport.DrawSurfaceHeight);
                CheckEqual(7, viewport.DrawSurfaceDeltaPosX);
                CheckEqual(-9, viewport.DrawSurfaceDeltaPosY);
            }

            public void ZeroSize_ClampsToOnePixel()
            {
                var viewport = new RecordingViewport(800, 600);
                viewport.Resize(0, 0);

                CheckEqual(1, viewport.Width);
                CheckEqual(1, viewport.Height);
            }

            public void ZeroSize_HandsTheDrawSurfaceTheClampedSize()
            {
                var viewport = new RecordingViewport(800, 600);
                viewport.Resize(0, 0);

                CheckEqual(1, viewport.DrawSurfaceWidth);
                CheckEqual(1, viewport.DrawSurfaceHeight);
            }

            public void NegativeSize_HandsTheDrawSurfaceTheClampedSize()
            {
                var viewport = new RecordingViewport(800, 600);
                viewport.Resize(-40, -30);

                CheckEqual(1, viewport.DrawSurfaceWidth);
                CheckEqual(1, viewport.DrawSurfaceHeight);
            }

            public void Always_ReportsTheChangeInSizeAndPosition()
            {
                var viewport = new RecordingViewport(800, 600);

                Vector reportedDeltaDims = Vector.Zero;
                Vector reportedDeltaPos = Vector.Zero;
                viewport.Resized += delegate (Vector deltaDims, Vector deltaPos)
                {
                    reportedDeltaDims = deltaDims;
                    reportedDeltaPos = deltaPos;
                };

                viewport.Resize(300, 400, 7, -9);

                CheckEqual(new Vector(-500, -200), reportedDeltaDims);
                CheckEqual(new Vector(7, -9), reportedDeltaPos);
            }

            public void ZeroSize_ReportsTheChangeAgainstTheClampedSize()
            {
                var viewport = new RecordingViewport(800, 600);

                Vector reportedDeltaDims = Vector.Zero;
                viewport.Resized += delegate (Vector deltaDims, Vector deltaPos)
                {
                    reportedDeltaDims = deltaDims;
                };

                viewport.Resize(0, 0);

                CheckEqual(new Vector(-799, -599), reportedDeltaDims);
            }
        }
    }
}