using System;
using Blacklight.Core.Keyboard;
using Clave;

namespace Blacklight.Core.UnitTests.Keyboard
{
    public class KeyboardResyncTests : UnitTestSharp.TestFixture
    {
        public const int LeftShift = 0xA0;
        public const int RightShift = 0xA1;
        public const int LeftControl = 0xA2;
        public const int RightControl = 0xA3;
        public const int LeftMenu = 0xA4;
        public const int RightMenu = 0xA5;

        public static bool[] Down(params int[] virtualKeys)
        {
            var returnMe = new bool[KeyboardResync.VirtualKeyCount];
            foreach (int virtualKey in virtualKeys)
            {
                returnMe[virtualKey] = true;
            }

            return returnMe;
        }

        public class ApplyTests : UnitTestSharp.TestFixture
        {
            public void NothingDown_HoldsNothing()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down());

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

            public void ALeftShift_IsHeldAsTheLeftShift()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(LeftShift));

                CheckEqual(new KeyState(KeyCode.ShiftLeft), keyboard.Physical.Held);
                CheckEqual(new KeyState(KeyCode.ShiftLeft), tracker.Held);
            }

            public void ARightShift_IsHeldAsTheRightShift()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(RightShift));

                CheckEqual(new KeyState(KeyCode.ShiftRight), keyboard.Physical.Held);
            }

            public void TheSidesOfControlAndAlt_AreHeldApart()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(LeftControl, RightControl, LeftMenu));

                var expected = new KeyState(KeyCode.ControlLeft, KeyCode.ControlRight, KeyCode.AltLeft);
                CheckEqual(expected, keyboard.Physical.Held);
            }

            public void ALetter_IsHeldUnderItsLayoutLetter()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(0x57));

                CheckEqual(new KeyState(KeyCode.W), keyboard.Layout.Held);
            }

            public void ADigit_IsHeldUnderItsLayoutDigit()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(0x32));

                CheckEqual(new KeyState(KeyCode.Digit2), keyboard.Layout.Held);
            }

            public void AKeyHasNoPressEdge()
            {
                var tracker = new KeyTracker();
                KeyboardResync.Apply(tracker, Down(LeftShift, 0x57));

                KeyboardSnapshot frame = tracker.NextFrame();

                CheckEqual(default(KeyState), frame.Physical.Pressed);
                CheckEqual(default(KeyState), frame.Layout.Pressed);
            }

            public void TheAltGrsFakeLeftControl_IsLeftOut()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(LeftControl, RightMenu));

                CheckEqual(new KeyState(KeyCode.AltRight), keyboard.Physical.Held);
            }

            public void ALeftControlWithoutAnAltGr_IsKept()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(LeftControl, LeftMenu));

                CheckTrue(keyboard.Physical.Held.IsKeySet(KeyCode.ControlLeft));
            }

            public void TheGenericModifiers_AreLeftOutSinceTheSidesAreRead()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(0x10, 0x11, 0x12));

                CheckEqual(default(KeyState), keyboard.Physical.Held);
            }

            public void TheMouseButtons_AreLeftOut()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(0x01, 0x02, 0x04, 0x05, 0x06));

                CheckEqual(default(KeyState), keyboard.Physical.Held);
            }

            public void TheImeProcessKey_IsLeftOut()
            {
                var tracker = new KeyTracker();

                KeyboardSnapshot keyboard = KeyboardResync.Apply(tracker, Down(RawKeyMessage.ProcessKeyVirtualKey));

                CheckEqual(default(KeyState), keyboard.Physical.Held);
            }

            public void AKeyAlreadyHeld_IsNotHeldTwice()
            {
                var tracker = new KeyTracker();
                tracker.KeyDown(KeyCode.ShiftLeft, KeyCode.None, isRepeat: false);

                KeyboardResync.Apply(tracker, Down(LeftShift));
                KeyboardSnapshot released = tracker.KeyUp(KeyCode.ShiftLeft);

                CheckEqual(default(KeyState), released.Physical.Held);
            }

            public void ANullArray_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                KeyboardResync.Apply(new KeyTracker(), null);
            }

            public void AnArrayOfTheWrongLength_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                KeyboardResync.Apply(new KeyTracker(), new bool[10]);
            }
        }

        public class ReadTests : UnitTestSharp.TestFixture
        {
            public void CoversEveryVirtualKey()
            {
                CheckEqual(KeyboardResync.VirtualKeyCount, KeyboardResync.Read().Length);
            }

            public void NeverFlagsTheMouseButtonsOrTheEdgesOfTheRange()
            {
                bool[] down = KeyboardResync.Read();

                CheckFalse(down[0]);
                CheckFalse(down[0xFF]);
            }
        }
    }
}