using Clave;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class ButtonBehaviorTests : TestFixture
    {
        // The chords a behavior asks about only exist in a manager while a button using it holds focus.
        public static KeyboardManager FocusedOn(ButtonBehavior behavior)
        {
            return new FocusedKeys(new Button(behavior)).Manager;
        }

        public class DefaultTests : TestFixture
        {
            public void IsFocusable()
            {
                CheckTrue(ButtonBehavior.Default.Focusable);
            }
        }

        public class MouseOnlyTests : TestFixture
        {
            public void IsNotFocusable()
            {
                CheckFalse(ButtonBehavior.MouseOnly.Focusable);
            }

            public void HasNoKeyChords()
            {
                CheckNull(ButtonBehavior.MouseOnly.KeyChords);
            }

            public void IgnoresEveryKeyEvent()
            {
                var behavior = ButtonBehavior.MouseOnly;
                var keys = new KeyboardManager();

                CheckFalse(behavior.Presses(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
                CheckFalse(behavior.Repeats(KeyboardManagerTests.Repeating(KeyCode.Space), keys));
                CheckFalse(behavior.Releases(KeyboardManagerTests.Releasing(KeyCode.Space), keys));
            }
        }

        public class CtorTests : TestFixture
        {
            public void KeepsFocusable()
            {
                var keys = new KeyState(KeyCode.F);

                CheckTrue(new ButtonBehavior(keys, focusable: true).Focusable);
                CheckFalse(new ButtonBehavior(keys, focusable: false).Focusable);
            }

            public void NoKeys_CanStillBeFocusable()
            {
                var behavior = new ButtonBehavior(default, focusable: true);

                CheckTrue(behavior.Focusable);
                CheckFalse(behavior.Presses(KeyboardManagerTests.Pressing(KeyCode.Space), new KeyboardManager()));
            }
        }

        public class KeyChordsTests : TestFixture
        {
            public void WithKeys_IsASetOfChords()
            {
                CheckNotNull(ButtonBehavior.Default.KeyChords);
            }

            public void IsTheUnionOfThePressRepeatAndReleaseChords()
            {
                ButtonBehavior behavior = ButtonBehavior.Default;

                CheckEqual(behavior.PressChords.Count + behavior.RepeatChords.Count + behavior.ReleaseChords.Count,
                    behavior.KeyChords.Count);
            }

            public void HoldsTheGroupsChordsThemselves()
            {
                ButtonBehavior behavior = ButtonBehavior.Default;

                foreach (Chord chord in behavior.PressChords)
                {
                    Check(behavior.KeyChords.Contains(chord));
                }

                foreach (Chord chord in behavior.RepeatChords)
                {
                    Check(behavior.KeyChords.Contains(chord));
                }

                foreach (Chord chord in behavior.ReleaseChords)
                {
                    Check(behavior.KeyChords.Contains(chord));
                }
            }

            public void TheGroupsShareNoChords()
            {
                ButtonBehavior behavior = ButtonBehavior.Default;

                foreach (Chord chord in behavior.PressChords)
                {
                    CheckFalse(behavior.RepeatChords.Contains(chord));
                    CheckFalse(behavior.ReleaseChords.Contains(chord));
                }

                foreach (Chord chord in behavior.RepeatChords)
                {
                    CheckFalse(behavior.ReleaseChords.Contains(chord));
                }
            }

            public void IsTheSameSetEveryTime()
            {
                CheckEqual(ButtonBehavior.Default.KeyChords, ButtonBehavior.Default.KeyChords);
            }

            public void MergesIntoAnotherSetAndBackOut()
            {
                var behavior = new ButtonBehavior(new KeyState(KeyCode.F, KeyCode.G), focusable: true);
                var set = new ChordSet();

                set.AddAll(behavior.KeyChords);
                set.RemoveAll(behavior.KeyChords);

                CheckEqual(0, set.Count);
            }

            public void HoldsAPressRepeatAndReleaseChordPerKey()
            {
                var behavior = new ButtonBehavior(new KeyState(KeyCode.F, KeyCode.G), focusable: true);

                CheckEqual(6, behavior.KeyChords.Count);
            }
        }

        public class ChordGroupsTests : TestFixture
        {
            public void HoldOneChordPerKeyInEachGroup()
            {
                var behavior = new ButtonBehavior(new KeyState(KeyCode.F, KeyCode.G), focusable: true);

                CheckEqual(2, behavior.PressChords.Count);
                CheckEqual(2, behavior.RepeatChords.Count);
                CheckEqual(2, behavior.ReleaseChords.Count);
            }

            public void DefaultHoldsThreeKeysWorth()
            {
                CheckEqual(3, ButtonBehavior.Default.PressChords.Count);
            }

            public void WithNoKeys_AreEmptyButStillThere()
            {
                CheckEqual(0, ButtonBehavior.MouseOnly.PressChords.Count);
                CheckEqual(0, ButtonBehavior.MouseOnly.RepeatChords.Count);
                CheckEqual(0, ButtonBehavior.MouseOnly.ReleaseChords.Count);
            }
        }

        public class PressesTests : TestFixture
        {
            public void ActivationKey_Matches()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckTrue(ButtonBehavior.Default.Presses(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
                CheckTrue(ButtonBehavior.Default.Presses(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
                CheckTrue(ButtonBehavior.Default.Presses(KeyboardManagerTests.Pressing(KeyCode.NumpadEnter), keys));
            }

            public void OtherKey_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Presses(KeyboardManagerTests.Pressing(KeyCode.A), keys));
            }

            public void AutoRepeat_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Presses(KeyboardManagerTests.Repeating(KeyCode.Space), keys));
            }

            public void Release_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Presses(KeyboardManagerTests.Releasing(KeyCode.Space), keys));
            }

            public void WithAnyModifierHeld_Matches()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckTrue(ButtonBehavior.Default.Presses(
                    KeyboardManagerTests.Pressing(KeyCode.Space, KeyCode.ShiftLeft), keys));
                CheckTrue(ButtonBehavior.Default.Presses(
                    KeyboardManagerTests.Pressing(KeyCode.Space, KeyCode.ControlRight), keys));
                CheckTrue(ButtonBehavior.Default.Presses(
                    KeyboardManagerTests.Pressing(KeyCode.Space, KeyCode.AltLeft), keys));
            }

            public void CustomKeys_ReplaceTheDefaults()
            {
                var behavior = new ButtonBehavior(new KeyState(KeyCode.F), focusable: true);
                KeyboardManager keys = FocusedOn(behavior);

                CheckTrue(behavior.Presses(KeyboardManagerTests.Pressing(KeyCode.F), keys));
                CheckFalse(behavior.Presses(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
            }

            public void ShortcutWithAStrongerChord_Hides()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);
                keys.AddShortcut(Chord.Press(KeyCode.Space).WithAnyHeld(KeyState.Control));

                CheckFalse(ButtonBehavior.Default.Presses(
                    KeyboardManagerTests.Pressing(KeyCode.Space, KeyCode.ControlLeft), keys));
                CheckTrue(ButtonBehavior.Default.Presses(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
            }

            public void ShortcutOnTheSameKey_LosesTheTie()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);
                keys.AddShortcut(Chord.Press(KeyCode.Space));

                CheckTrue(ButtonBehavior.Default.Presses(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
            }
        }

        public class RepeatsTests : TestFixture
        {
            public void ActivationKeyAutoRepeating_Matches()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckTrue(ButtonBehavior.Default.Repeats(KeyboardManagerTests.Repeating(KeyCode.Space), keys));
            }

            public void OtherKeyAutoRepeating_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Repeats(KeyboardManagerTests.Repeating(KeyCode.A), keys));
            }

            public void InitialPress_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Repeats(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
            }
        }

        public class ReleasesTests : TestFixture
        {
            public void ActivationKey_Matches()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckTrue(ButtonBehavior.Default.Releases(KeyboardManagerTests.Releasing(KeyCode.Space), keys));
                CheckTrue(ButtonBehavior.Default.Releases(KeyboardManagerTests.Releasing(KeyCode.MainEnter), keys));
                CheckTrue(ButtonBehavior.Default.Releases(KeyboardManagerTests.Releasing(KeyCode.NumpadEnter), keys));
            }

            public void OtherKey_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Releases(KeyboardManagerTests.Releasing(KeyCode.A), keys));
            }

            public void Press_DoesNotMatch()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckFalse(ButtonBehavior.Default.Releases(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
            }

            public void WithControlHeld_StillMatches()
            {
                KeyboardManager keys = FocusedOn(ButtonBehavior.Default);

                CheckTrue(ButtonBehavior.Default.Releases(
                    KeyboardManagerTests.Releasing(KeyCode.Space, KeyCode.ControlLeft), keys));
            }
        }
    }
}