using Blacklight.Core.Keyboard;
using UnitTestSharp;

namespace Blacklight.Core.UnitTests.Keyboard
{
    public class ChordTests : TestFixture
    {
        public class EqualityTests : EqualityTestFixture<Chord>
        {
            public EqualityTests() : base(new Chord(new KeyState(KeyCode.A), new KeyState(KeyCode.B))) { }
        }

        public class CtorTests : TestFixture
        {
            public void SingleArg_MakesEveryRequiredKeyATrigger()
            {
                KeyState required = new KeyState(KeyCode.A, KeyCode.R, KeyCode.Y, KeyCode.Period);

                CheckEqual(required, new Chord(required).Triggers);
            }
        }

        public class MatchesTests : TestFixture
        {
            // The reactor-vent example: hold A, R, Y and Period, then press Up repeatedly.
            private static readonly KeyState ReactorHeld =
                new KeyState(KeyCode.A, KeyCode.R, KeyCode.Y, KeyCode.Period, KeyCode.ArrowUp);

            public void AnyRequiredKey_CanTriggerWhenTriggersIsTheWholeSet()
            {
                var chord = new Chord(ReactorHeld);

                Check(chord.Matches(KeyCode.ArrowUp, ReactorHeld));
                Check(chord.Matches(KeyCode.A, ReactorHeld));
                Check(chord.Matches(KeyCode.R, ReactorHeld));
            }

            public void OnlyTheRestrictedKeys_TriggerWhenTriggersIsNarrower()
            {
                var chord = new Chord(ReactorHeld, new KeyState(KeyCode.ArrowUp, KeyCode.Y));

                Check(chord.Matches(KeyCode.ArrowUp, ReactorHeld));
                Check(chord.Matches(KeyCode.Y, ReactorHeld));
                CheckFalse(chord.Matches(KeyCode.A, ReactorHeld));
                CheckFalse(chord.Matches(KeyCode.R, ReactorHeld));
                CheckFalse(chord.Matches(KeyCode.Period, ReactorHeld));
            }

            public void OneRequiredKeyMissing_DoesNotMatch()
            {
                var chord = new Chord(ReactorHeld);
                KeyState missingPeriod = new KeyState(KeyCode.A, KeyCode.R, KeyCode.Y, KeyCode.ArrowUp);

                CheckFalse(chord.Matches(KeyCode.ArrowUp, missingPeriod));
            }

            public void ExtraKeysHeldBesidesTheChord_StillMatches()
            {
                var chord = new Chord(ReactorHeld);
                KeyState withExtra = ReactorHeld.WithSet(KeyCode.ShiftLeft);

                Check(chord.Matches(KeyCode.ArrowUp, withExtra));
            }

            public void KeyOutsideTriggers_DoesNotMatchEvenIfEverythingIsHeld()
            {
                var chord = new Chord(ReactorHeld, new KeyState(KeyCode.ArrowUp));

                CheckFalse(chord.Matches(KeyCode.A, ReactorHeld));
            }

            public void EitherSideOfAModifier_IsComposedFromTwoChords()
            {
                var withLeftShift = new Chord(new KeyState(KeyCode.ShiftLeft, KeyCode.Q));
                var withRightShift = new Chord(new KeyState(KeyCode.ShiftRight, KeyCode.Q));

                KeyState heldWithRight = new KeyState(KeyCode.ShiftRight, KeyCode.Q);

                CheckFalse(withLeftShift.Matches(KeyCode.Q, heldWithRight));
                Check(withRightShift.Matches(KeyCode.Q, heldWithRight));
            }
        }
    }
}