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

namespace Blacklight.Core.UnitTests.Keyboard
{
    public class PointerKeyRouterTests : TestFixture
    {
        public class Consumer : IInputConsumer
        {
            public bool TakesPointer;
            public bool TakesKeys;

            public int PointerDowns;
            public int PointerUps;
            public int Wheels;
            public int KeyDowns;
            public int KeyUps;
            public KeyboardSnapshot LastKeyDown;
            public KeyboardSnapshot LastKeyUp;

            public bool PointerDown(PointerInput input)
            {
                ++PointerDowns;

                return TakesPointer;
            }

            public bool PointerMove(PointerInput input)
            {
                return false;
            }

            public bool PointerUp(PointerInput input)
            {
                ++PointerUps;

                return TakesPointer;
            }

            public bool Wheel(Scalar ticks, Vector pixelPos)
            {
                ++Wheels;

                return TakesPointer;
            }

            public bool KeyDown(KeyboardSnapshot keyboard)
            {
                ++KeyDowns;
                LastKeyDown = keyboard;

                return TakesKeys;
            }

            public bool KeyUp(KeyboardSnapshot keyboard)
            {
                ++KeyUps;
                LastKeyUp = keyboard;

                return TakesKeys;
            }

            public void SyncKeys(KeyboardSnapshot keyboard)
            {
            }

            public void CancelKeys()
            {
            }
        }

        public static PointerInput Button(PointerButtons button)
        {
            return new PointerInput { PixelPos = Vector.Zero, Buttons = button };
        }

        public class KeyOfTests : TestFixture
        {
            public void EachButton_IsItsKey()
            {
                CheckEqual(KeyCode.MouseLeft, PointerKeyRouter.KeyOf(PointerButtons.Left));
                CheckEqual(KeyCode.MouseMiddle, PointerKeyRouter.KeyOf(PointerButtons.Middle));
                CheckEqual(KeyCode.MouseRight, PointerKeyRouter.KeyOf(PointerButtons.Right));
                CheckEqual(KeyCode.MouseBack, PointerKeyRouter.KeyOf(PointerButtons.Back));
                CheckEqual(KeyCode.MouseForward, PointerKeyRouter.KeyOf(PointerButtons.Forward));
            }

            public void NoButtonOrSeveral_IsNone()
            {
                CheckEqual(KeyCode.None, PointerKeyRouter.KeyOf(PointerButtons.None));
                CheckEqual(KeyCode.None, PointerKeyRouter.KeyOf(PointerButtons.Left | PointerButtons.Right));
            }
        }

        public class ButtonDownTests : TestFixture
        {
            public void ClaimedByThePointer_NeverReachesTheKeys()
            {
                var consumer = new Consumer { TakesPointer = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.PointerDown(Button(PointerButtons.Left)));
                CheckEqual(0, consumer.KeyDowns);
            }

            public void DeclinedByThePointer_ReachesTheKeysWithTheButtonPressed()
            {
                var consumer = new Consumer { TakesKeys = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.PointerDown(Button(PointerButtons.Left)));
                CheckEqual(1, consumer.PointerDowns);
                CheckEqual(new KeyState(KeyCode.MouseLeft), consumer.LastKeyDown.Physical.Pressed);
            }

            public void ClaimedByThePointer_StillHoldsTheButtonInTheTracker()
            {
                var tracker = new KeyTracker();
                var router = new PointerKeyRouter(tracker, new Consumer { TakesPointer = true });

                router.PointerDown(Button(PointerButtons.Left));

                CheckEqual(new KeyState(KeyCode.MouseLeft), tracker.Held);
            }

            public void ButtonWithNoPointerMeaning_GoesStraightToTheKeys()
            {
                var consumer = new Consumer { TakesPointer = true, TakesKeys = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.PointerDown(Button(PointerButtons.Back)));
                CheckEqual(0, consumer.PointerDowns);
                CheckEqual(new KeyState(KeyCode.MouseBack), consumer.LastKeyDown.Physical.Pressed);
            }

            public void NoSingleButton_GoesToThePointerOnly()
            {
                var consumer = new Consumer { TakesPointer = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.PointerDown(Button(PointerButtons.Left | PointerButtons.Right)));
                CheckEqual(1, consumer.PointerDowns);
                CheckEqual(0, consumer.KeyDowns);
            }
        }

        public class ButtonUpTests : TestFixture
        {
            public void AfterAPressTheKeysSaw_ReachesTheKeysToo()
            {
                var consumer = new Consumer();
                var router = new PointerKeyRouter(new KeyTracker(), consumer);
                router.PointerDown(Button(PointerButtons.Left));

                router.PointerUp(Button(PointerButtons.Left));

                CheckEqual(1, consumer.PointerUps);
                CheckEqual(1, consumer.KeyUps);
                CheckEqual(new KeyState(KeyCode.MouseLeft), consumer.LastKeyUp.Physical.Released);
            }

            public void AfterAPressThePointerClaimed_NeverReachesTheKeys()
            {
                var consumer = new Consumer { TakesPointer = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);
                router.PointerDown(Button(PointerButtons.Left));

                CheckTrue(router.PointerUp(Button(PointerButtons.Left)));
                CheckEqual(0, consumer.KeyUps);
            }

            public void ClaimedByThePointer_StillReleasesTheButtonInTheTracker()
            {
                var tracker = new KeyTracker();
                var router = new PointerKeyRouter(tracker, new Consumer { TakesPointer = true });
                router.PointerDown(Button(PointerButtons.Left));

                router.PointerUp(Button(PointerButtons.Left));

                CheckEqual(default(KeyState), tracker.Held);
            }

            public void ButtonWithNoPointerMeaning_ReachesOnlyTheKeys()
            {
                var consumer = new Consumer { TakesKeys = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);
                router.PointerDown(Button(PointerButtons.Forward));

                CheckTrue(router.PointerUp(Button(PointerButtons.Forward)));
                CheckEqual(0, consumer.PointerUps);
                CheckEqual(1, consumer.KeyUps);
            }

            public void AfterReset_NoLongerReachesTheKeys()
            {
                var consumer = new Consumer();
                var router = new PointerKeyRouter(new KeyTracker(), consumer);
                router.PointerDown(Button(PointerButtons.Left));

                router.Reset();
                router.PointerUp(Button(PointerButtons.Left));

                CheckEqual(0, consumer.KeyUps);
            }

            public void NoSingleButton_GoesToThePointerOnly()
            {
                var consumer = new Consumer { TakesPointer = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.PointerUp(Button(PointerButtons.None)));
                CheckEqual(1, consumer.PointerUps);
                CheckEqual(0, consumer.KeyUps);
            }
        }

        public class WheelTests : TestFixture
        {
            public void ClaimedByThePointer_NeverReachesTheKeys()
            {
                var consumer = new Consumer { TakesPointer = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.Wheel(120, Vector.Zero));
                CheckEqual(0, consumer.KeyDowns);
            }

            public void Away_IsOneWheelUpNotchPressedAndReleased()
            {
                var consumer = new Consumer { TakesKeys = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckTrue(router.Wheel(240, Vector.Zero));
                CheckEqual(new KeyState(KeyCode.WheelUp), consumer.LastKeyDown.Physical.Pressed);
                CheckEqual(new KeyState(KeyCode.WheelUp), consumer.LastKeyUp.Physical.Released);
                CheckEqual(1, consumer.KeyDowns);
                CheckEqual(1, consumer.KeyUps);
            }

            public void Toward_IsWheelDown()
            {
                var consumer = new Consumer();
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                router.Wheel(-120, Vector.Zero);

                CheckEqual(new KeyState(KeyCode.WheelDown), consumer.LastKeyDown.Physical.Pressed);
            }

            public void NoMovement_ReachesNoKeys()
            {
                var consumer = new Consumer { TakesKeys = true };
                var router = new PointerKeyRouter(new KeyTracker(), consumer);

                CheckFalse(router.Wheel(0, Vector.Zero));
                CheckEqual(0, consumer.KeyDowns);
            }

            public void LeavesNothingHeld()
            {
                var tracker = new KeyTracker();
                var router = new PointerKeyRouter(tracker, new Consumer());

                router.Wheel(120, Vector.Zero);

                CheckEqual(default(KeyState), tracker.Held);
            }
        }
    }
}