using Clave;
using System;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class DialogBehaviorTests : TestFixture
    {
        /// <summary>
        /// A focus scope holding a behavior's chords, entered so the chords are in play.
        /// </summary>
        public static KeyboardManager Entered(DialogBehavior behavior)
        {
            var manager = new KeyboardManager();
            var scope = new KeyboardManagerTests.KeyRecorder
            {
                FocusScope = new FocusScope(),
                Chords = behavior.KeyChords,
            };
            manager.Controls.Add(scope);
            manager.EnterScope(scope);

            return manager;
        }

        public class NoKeysTests : TestFixture
        {
            public void HasNoChords()
            {
                CheckNull(DialogBehavior.NoKeys.KeyChords);
            }

            public void NeitherAcceptsNorCancels()
            {
                KeyboardManager keys = Entered(DialogBehavior.NoKeys);

                CheckFalse(DialogBehavior.NoKeys.Accepts(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
                CheckFalse(DialogBehavior.NoKeys.Cancels(KeyboardManagerTests.Pressing(KeyCode.Escape), keys));
            }
        }

        public class DismissOnOutsidePressTests : TestFixture
        {
            public void DefaultKeepsTheBoxUp()
            {
                CheckFalse(DialogBehavior.Default.DismissOnOutsidePress);
            }

            public void NoKeysKeepsTheBoxUp()
            {
                CheckFalse(DialogBehavior.NoKeys.DismissOnOutsidePress);
            }

            public void IsKept()
            {
                var behavior = new DialogBehavior(default, default, dismissOnOutsidePress: true);

                CheckTrue(behavior.DismissOnOutsidePress);
            }
        }

        public class CtorTests : TestFixture
        {
            public void AKeyThatBothAcceptsAndCancels_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new DialogBehavior(
                    new KeyState(KeyCode.Y, KeyCode.N), new KeyState(KeyCode.N), dismissOnOutsidePress: false);
            }

            public void OnlyAcceptKeys_StillHasChords()
            {
                var behavior = new DialogBehavior(new KeyState(KeyCode.Y), default, dismissOnOutsidePress: false);

                CheckNotNull(behavior.KeyChords);
            }

            public void OnlyCancelKeys_StillHasChords()
            {
                var behavior = new DialogBehavior(default, new KeyState(KeyCode.N), dismissOnOutsidePress: false);

                CheckNotNull(behavior.KeyChords);
            }

            public void HoldsOneChordPerKey()
            {
                var behavior = new DialogBehavior(
                    new KeyState(KeyCode.Y, KeyCode.U), new KeyState(KeyCode.N), dismissOnOutsidePress: false);

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

        public class ChordGroupsTests : TestFixture
        {
            public void HoldOneChordPerKeyInEachGroup()
            {
                CheckEqual(2, DialogBehavior.Default.AcceptChords.Count);
                CheckEqual(1, DialogBehavior.Default.CancelChords.Count);
            }

            public void KeyChordsHoldsBothGroupsChords()
            {
                DialogBehavior behavior = DialogBehavior.Default;

                CheckEqual(3, behavior.KeyChords.Count);

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

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

            public void WithNoKeys_AreEmptyButStillThere()
            {
                CheckEqual(0, DialogBehavior.NoKeys.AcceptChords.Count);
                CheckEqual(0, DialogBehavior.NoKeys.CancelChords.Count);
            }

            public void OnlyCancelKeys_LeaveTheAcceptGroupEmpty()
            {
                var behavior = new DialogBehavior(default, new KeyState(KeyCode.N), dismissOnOutsidePress: false);

                CheckEqual(0, behavior.AcceptChords.Count);
                CheckEqual(1, behavior.CancelChords.Count);
            }
        }

        public class AcceptsTests : TestFixture
        {
            public void AnAcceptKeyGoingDown_Matches()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckTrue(DialogBehavior.Default.Accepts(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
                CheckTrue(DialogBehavior.Default.Accepts(KeyboardManagerTests.Pressing(KeyCode.NumpadEnter), keys));
            }

            public void ACancelKey_DoesNotMatch()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckFalse(DialogBehavior.Default.Accepts(KeyboardManagerTests.Pressing(KeyCode.Escape), keys));
            }

            public void OtherKey_DoesNotMatch()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckFalse(DialogBehavior.Default.Accepts(KeyboardManagerTests.Pressing(KeyCode.Space), keys));
            }

            public void AutoRepeat_DoesNotMatch()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckFalse(DialogBehavior.Default.Accepts(KeyboardManagerTests.Repeating(KeyCode.MainEnter), keys));
            }

            public void Release_DoesNotMatch()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckFalse(DialogBehavior.Default.Accepts(KeyboardManagerTests.Releasing(KeyCode.MainEnter), keys));
            }

            public void WithAModifierHeld_Matches()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckTrue(DialogBehavior.Default.Accepts(
                    KeyboardManagerTests.Pressing(KeyCode.MainEnter, KeyCode.ControlLeft), keys));
            }

            public void CustomKeys_ReplaceTheDefaults()
            {
                var behavior = new DialogBehavior(
                    new KeyState(KeyCode.Y), new KeyState(KeyCode.N), dismissOnOutsidePress: false);
                KeyboardManager keys = Entered(behavior);

                CheckTrue(behavior.Accepts(KeyboardManagerTests.Pressing(KeyCode.Y), keys));
                CheckFalse(behavior.Accepts(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
            }

            public void AShortcutWithAStrongerChord_Hides()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);
                keys.AddShortcut(Chord.Press(KeyCode.MainEnter).WithAnyHeld(KeyState.Alt));

                CheckFalse(DialogBehavior.Default.Accepts(
                    KeyboardManagerTests.Pressing(KeyCode.MainEnter, KeyCode.AltLeft), keys));
                CheckTrue(DialogBehavior.Default.Accepts(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
            }

            public void AShortcutOnTheSameKey_LosesTheTie()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);
                keys.AddShortcut(Chord.Press(KeyCode.MainEnter));

                CheckTrue(DialogBehavior.Default.Accepts(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
            }
        }

        public class CancelsTests : TestFixture
        {
            public void ACancelKeyGoingDown_Matches()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckTrue(DialogBehavior.Default.Cancels(KeyboardManagerTests.Pressing(KeyCode.Escape), keys));
            }

            public void AnAcceptKey_DoesNotMatch()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckFalse(DialogBehavior.Default.Cancels(KeyboardManagerTests.Pressing(KeyCode.MainEnter), keys));
            }

            public void AutoRepeat_DoesNotMatch()
            {
                KeyboardManager keys = Entered(DialogBehavior.Default);

                CheckFalse(DialogBehavior.Default.Cancels(KeyboardManagerTests.Repeating(KeyCode.Escape), keys));
            }

        }
    }
}