using System;
using UnitTestSharp;

namespace Clave.UnitTests
{
    public class KeyStateTests : TestFixture
    {
        public class EqualityTests : EqualityTestFixture<KeyState>
        {
            public EqualityTests() : base(new KeyState(KeyCode.A, KeyCode.Numpad0)) { }
        }

        public class EqualityOperatorTests : TestFixture
        {
            public void EqualStates_AreEqual()
            {
                Check(new KeyState(KeyCode.A) == new KeyState(KeyCode.A));
            }

            public void DifferentStates_AreNotEqual()
            {
                Check(new KeyState(KeyCode.A) != new KeyState(KeyCode.B));
            }

            public void EqualStates_HaveEqualHashCodes()
            {
                CheckEqual(new KeyState(KeyCode.A).GetHashCode(), new KeyState(KeyCode.A).GetHashCode());
            }
        }

        public class CtorTests : TestFixture
        {
            public void SingleKey_SetsIt()
            {
                Check(new KeyState(KeyCode.A).IsKeySet(KeyCode.A));
            }

            public void MultipleKeys_SetsThemAll()
            {
                KeyState state = new KeyState(KeyCode.A, KeyCode.R, KeyCode.Y, KeyCode.Period);

                Check(state.IsKeySet(KeyCode.A));
                Check(state.IsKeySet(KeyCode.R));
                Check(state.IsKeySet(KeyCode.Y));
                Check(state.IsKeySet(KeyCode.Period));
            }

            public void NoKeys_IsEmpty()
            {
                CheckEqual(default(KeyState), new KeyState());
            }

            public void SingleKeyOverloadAndParamsOverload_AgreeForOneKey()
            {
                CheckEqual(new KeyState(KeyCode.A), new KeyState(new[] { KeyCode.A }));
            }

            public void NoneKey_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState(KeyCode.None);
            }

            public void NoneAmongSeveralKeys_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState(KeyCode.A, KeyCode.None, KeyCode.B);
            }

            public void UndefinedKeyWithinCapacity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState((KeyCode)120);
            }

            public void KeyBeyondCapacity_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState((KeyCode)(KeyState.Capacity + 2));
            }

            public void NegativeKey_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState((KeyCode)(-1));
            }
        }

        public class IsKeySetTests : TestFixture
        {
            public void EveryRealKeyCode_IsSetOnlyForItself()
            {
                foreach (KeyCode expected in Enum.GetValues(typeof(KeyCode)))
                {
                    if (expected == KeyCode.None)
                    {
                        continue;
                    }

                    KeyState state = new KeyState(expected);

                    foreach (KeyCode other in Enum.GetValues(typeof(KeyCode)))
                    {
                        CheckEqual(other == expected, state.IsKeySet(other));
                    }
                }
            }

            public void None_IsNeverSet()
            {
                CheckFalse(default(KeyState).IsKeySet(KeyCode.None));
                CheckFalse(new KeyState(KeyCode.A, KeyCode.B).IsKeySet(KeyCode.None));
            }
        }

        public class WithKeySetTests : TestFixture
        {
            public void None_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                default(KeyState).WithKeySet(KeyCode.None);
            }

            public void UndefinedKey_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                default(KeyState).WithKeySet((KeyCode)120);
            }

            public void SetsTheKey()
            {
                Check(default(KeyState).WithKeySet(KeyCode.A).IsKeySet(KeyCode.A));
            }

            public void LeavesOtherKeysAlone()
            {
                KeyState state = new KeyState(KeyCode.A).WithKeySet(KeyCode.B);

                Check(state.IsKeySet(KeyCode.A));
            }

            public void DoesNotMutateTheOriginal()
            {
                KeyState original = default(KeyState);

                original.WithKeySet(KeyCode.A);

                CheckFalse(original.IsKeySet(KeyCode.A));
            }
        }

        public class WithKeyClearedTests : TestFixture
        {
            public void None_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState(KeyCode.A).WithKeyCleared(KeyCode.None);
            }

            public void UndefinedKey_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                new KeyState(KeyCode.A).WithKeyCleared((KeyCode)120);
            }

            public void ClearsAKeyThatWasSet()
            {
                CheckFalse(new KeyState(KeyCode.A).WithKeyCleared(KeyCode.A).IsKeySet(KeyCode.A));
            }

            public void KeyThatWasNeverSet_StaysUnset()
            {
                CheckFalse(default(KeyState).WithKeyCleared(KeyCode.A).IsKeySet(KeyCode.A));
            }

            public void LeavesOtherKeysAlone()
            {
                KeyState state = new KeyState(KeyCode.A, KeyCode.B).WithKeyCleared(KeyCode.B);

                Check(state.IsKeySet(KeyCode.A));
            }

            public void DoesNotMutateTheOriginal()
            {
                KeyState original = new KeyState(KeyCode.A);

                original.WithKeyCleared(KeyCode.A);

                Check(original.IsKeySet(KeyCode.A));
            }
        }

        public class ContainsAnyKeysTests : TestFixture
        {
            public void OneOfTheKeysSet_IsTrue()
            {
                Check(new KeyState(KeyCode.ShiftRight).ContainsAnyKeys(KeyState.Shift));
            }

            public void NoneOfTheKeysSet_IsFalse()
            {
                CheckFalse(new KeyState(KeyCode.A).ContainsAnyKeys(KeyState.Shift));
            }

            public void EmptySet_IsAlwaysFalse()
            {
                CheckFalse(new KeyState(KeyCode.A).ContainsAnyKeys(default(KeyState)));
            }
        }

        public class AndOperatorTests : TestFixture
        {
            public void KeepsOnlyKeysInBoth()
            {
                KeyState a = new KeyState(KeyCode.A, KeyCode.B);
                KeyState b = new KeyState(KeyCode.B, KeyCode.C);

                CheckEqual(new KeyState(KeyCode.B), a & b);
            }

            public void NeitherSet_IsEmpty()
            {
                CheckEqual(default(KeyState), new KeyState(KeyCode.A) & new KeyState(KeyCode.B));
            }
        }

        public class OrOperatorTests : TestFixture
        {
            public void UnionsBothSets()
            {
                KeyState a = new KeyState(KeyCode.A);
                KeyState b = new KeyState(KeyCode.B);

                CheckEqual(new KeyState(KeyCode.A, KeyCode.B), a | b);
            }
        }

        public class NotOperatorTests : TestFixture
        {
            public void FlipsASetKeyToUnset()
            {
                CheckFalse((~new KeyState(KeyCode.A)).IsKeySet(KeyCode.A));
            }

            public void FlipsAnUnsetKeyToSet()
            {
                Check((~new KeyState(KeyCode.A)).IsKeySet(KeyCode.B));
            }

            public void Empty_BecomesEveryRealKey()
            {
                KeyState flipped = ~default(KeyState);

                foreach (KeyCode keyCode in Enum.GetValues(typeof(KeyCode)))
                {
                    CheckEqual(keyCode != KeyCode.None, flipped.IsKeySet(keyCode));
                }
            }

            public void NeverSetsBitsForKeysThatDontExist()
            {
                CheckFalse((~default(KeyState)).IsKeySet((KeyCode)127));
            }

            public void Twice_IsTheOriginal()
            {
                KeyState state = new KeyState(KeyCode.A, KeyCode.Numpad9);

                CheckEqual(state, ~~state);
            }
        }

        public class EdgeDetectionTests : TestFixture
        {
            public void RisingEdge_FindsOnlyTheNewlySetKey()
            {
                KeyState previous = new KeyState(KeyCode.A);
                KeyState current = new KeyState(KeyCode.A, KeyCode.B);

                KeyState pressed = current & ~previous;

                Check(pressed.IsKeySet(KeyCode.B));
                CheckFalse(pressed.IsKeySet(KeyCode.A));
            }

            public void FallingEdge_FindsOnlyTheClearedKey()
            {
                KeyState previous = new KeyState(KeyCode.A, KeyCode.B);
                KeyState current = new KeyState(KeyCode.A);

                KeyState released = previous & ~current;

                Check(released.IsKeySet(KeyCode.B));
                CheckFalse(released.IsKeySet(KeyCode.A));
            }
        }

        public class AggregatesTests : TestFixture
        {
            public void Shift_IsEitherShiftKey()
            {
                Check(new KeyState(KeyCode.ShiftLeft).ContainsAnyKeys(KeyState.Shift));
                Check(new KeyState(KeyCode.ShiftRight).ContainsAnyKeys(KeyState.Shift));
                CheckFalse(new KeyState(KeyCode.A).ContainsAnyKeys(KeyState.Shift));
            }

            public void Control_IsEitherControlKey()
            {
                Check(new KeyState(KeyCode.ControlLeft).ContainsAnyKeys(KeyState.Control));
                Check(new KeyState(KeyCode.ControlRight).ContainsAnyKeys(KeyState.Control));
            }

            public void Alt_IsEitherAltKey()
            {
                Check(new KeyState(KeyCode.AltLeft).ContainsAnyKeys(KeyState.Alt));
                Check(new KeyState(KeyCode.AltRight).ContainsAnyKeys(KeyState.Alt));
            }

            public void Enter_IsEitherEnterKey()
            {
                Check(new KeyState(KeyCode.MainEnter).ContainsAnyKeys(KeyState.Enter));
                Check(new KeyState(KeyCode.NumpadEnter).ContainsAnyKeys(KeyState.Enter));
            }

            public void Typing_HoldsTheKeysThatMakeCharacters()
            {
                foreach (KeyCode key in new[] { KeyCode.A, KeyCode.Z, KeyCode.Digit0, KeyCode.Digit9, KeyCode.Space,
                    KeyCode.Minus, KeyCode.Backquote, KeyCode.Numpad5, KeyCode.NumpadAdd, KeyCode.NumpadDecimal })
                {
                    Check(new KeyState(key).ContainsAnyKeys(KeyState.Typing));
                }
            }

            public void Typing_LeavesOutEveryOtherKey()
            {
                foreach (KeyCode key in new[] { KeyCode.F1, KeyCode.F12, KeyCode.ArrowLeft, KeyCode.Home,
                    KeyCode.Delete, KeyCode.Backspace, KeyCode.Tab, KeyCode.Escape, KeyCode.MainEnter,
                    KeyCode.NumpadEnter, KeyCode.ShiftLeft, KeyCode.ControlRight, KeyCode.AltLeft, KeyCode.CapsLock,
                    KeyCode.ContextMenu })
                {
                    CheckFalse(new KeyState(key).ContainsAnyKeys(KeyState.Typing));
                }
            }

            public void AggregatesDoNotOverlapEachOther()
            {
                CheckEqual(default(KeyState), KeyState.Shift & KeyState.Control);
                CheckEqual(default(KeyState), KeyState.Control & KeyState.Alt);
                CheckEqual(default(KeyState), KeyState.Alt & KeyState.Enter);
                CheckEqual(default(KeyState), KeyState.Typing & KeyState.Shift);
                CheckEqual(default(KeyState), KeyState.Typing & KeyState.Control);
                CheckEqual(default(KeyState), KeyState.Typing & KeyState.Alt);
                CheckEqual(default(KeyState), KeyState.Typing & KeyState.Enter);
            }
        }
    }
}