using Annulus;
using Azimuth;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class MenuBarTests : TestFixture
    {
        public static readonly Vector OnTheFirstHeader = new Vector(50, 15);

        public static readonly Vector OnTheSecondHeader = new Vector(150, 15);

        public static readonly Vector OnTheFirstMenusFirstItem = new Vector(20, 38);

        public static readonly Vector AwayFromEverything = new Vector(500, 300);

        public static Rect Box(Scalar x, Scalar y, Scalar width, Scalar height)
        {
            return DropdownPopupTests.Box(x, y, width, height);
        }

        public static MouseState At(Vector position)
        {
            return DropdownPopupTests.At(position);
        }

        /// <summary>
        /// A bar across the top of the screen holding two 100 wide menus side by side, each with two items.
        /// </summary>
        public class TwoMenuBar
        {
            public readonly MenuBar Bar = new MenuBar { Bounds = Box(0, 0, 800, 30) };
            public readonly MenuButton First = NewHeader("first", Box(0, 0, 100, 30));
            public readonly MenuButton Second = NewHeader("second", Box(100, 0, 100, 30));

            public TwoMenuBar()
            {
                First.Group = Bar.Group;
                Second.Group = Bar.Group;
                Bar.CanvasChildren.Add(First);
                Bar.CanvasChildren.Add(Second);
            }

            public static MenuButton NewHeader(string debugName, Rect bounds)
            {
                var header = new MenuButton { DebugName = debugName, Bounds = bounds };
                header.Popup.ScrollViewMaterial = ScrollViewTests.WithBars(DropdownPopupTests.Thickness);
                header.Rebuild(new[] { DropdownTests.NarrowLabel, DropdownTests.WideLabel });
                return header;
            }
        }

        public static MenuBar OpenBar()
        {
            var menus = new TwoMenuBar();
            menus.First.Checked = true;
            return menus.Bar;
        }

        public class CtorTests : TestFixture
        {
            public void Always_StartsNotModalWithNothingSelected()
            {
                var bar = new MenuBar();

                CheckFalse(bar.Modal);
                CheckNull(bar.Group.Selected);
            }
        }

        public class GroupTests : TestFixture
        {
            public void OpeningAMenu_MakesTheBarModal()
            {
                var menus = new TwoMenuBar();

                menus.First.Checked = true;

                CheckTrue(menus.Bar.Modal);
            }

            public void ClosingTheOpenMenu_MakesTheBarNotModal()
            {
                var menus = new TwoMenuBar();
                menus.First.Checked = true;

                menus.First.Checked = false;

                CheckFalse(menus.Bar.Modal);
            }

            public void SwitchingMenus_KeepsTheBarModal()
            {
                var menus = new TwoMenuBar();
                menus.First.Checked = true;

                menus.Second.Checked = true;

                CheckTrue(menus.Bar.Modal);
            }
        }

        public class MouseDownTests : TestFixture
        {
            public void WhileAMenuIsOpen_ClosesItAndClaimsTheEvent()
            {
                var menus = new TwoMenuBar();
                menus.First.Checked = true;

                CheckTrue(menus.Bar.MouseDown(At(AwayFromEverything), MouseButtonFlags.Left));
                CheckFalse(menus.First.Checked);
            }

            public void WhileNothingIsOpen_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.MouseDown(At(AwayFromEverything), MouseButtonFlags.Left));
            }
        }

        public class MouseUpTests : TestFixture
        {
            public void WhileOpen_ClaimsTheEvent()
            {
                CheckTrue(OpenBar().MouseUp(At(AwayFromEverything), MouseButtonFlags.Left));
            }

            public void WhileClosed_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.MouseUp(At(AwayFromEverything), MouseButtonFlags.Left));
            }
        }

        public class MouseMoveStartTests : TestFixture
        {
            public void WhileOpen_ClaimsTheEvent()
            {
                CheckTrue(OpenBar().MouseMoveStart(At(AwayFromEverything)));
            }

            public void WhileClosed_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.MouseMoveStart(At(AwayFromEverything)));
            }
        }

        public class MouseMoveTests : TestFixture
        {
            public void WhileOpen_ClaimsTheEvent()
            {
                CheckTrue(OpenBar().MouseMove(At(AwayFromEverything)));
            }

            public void WhileClosed_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.MouseMove(At(AwayFromEverything)));
            }
        }

        public class MouseMoveEndTests : TestFixture
        {
            public void WhileOpen_ClaimsTheEvent()
            {
                CheckTrue(OpenBar().MouseMoveEnd(At(AwayFromEverything)));
            }

            public void WhileClosed_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.MouseMoveEnd(At(AwayFromEverything)));
            }
        }

        public class ClickTests : TestFixture
        {
            public void WhileOpen_ClaimsTheEvent()
            {
                CheckTrue(OpenBar().Click(At(AwayFromEverything), MouseButtonFlags.Left));
            }

            public void WhileClosed_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.Click(At(AwayFromEverything), MouseButtonFlags.Left));
            }
        }

        public class MouseWheelTests : TestFixture
        {
            public void WhileOpen_ClaimsTheEvent()
            {
                CheckTrue(OpenBar().MouseWheel(At(AwayFromEverything), notches: 1));
            }

            public void WhileClosed_LetsTheEventThrough()
            {
                CheckFalse(new TwoMenuBar().Bar.MouseWheel(At(AwayFromEverything), notches: 1));
            }
        }

        public class EnabledTests : TestFixture
        {
            public void Disabling_ClosesTheOpenMenu()
            {
                var menus = new TwoMenuBar();
                menus.First.Checked = true;

                menus.Bar.Enabled = false;

                CheckFalse(menus.First.Checked);
                CheckFalse(menus.Bar.Modal);
            }
        }

        public class VisibleTests : TestFixture
        {
            public void Hiding_ClosesTheOpenMenu()
            {
                var menus = new TwoMenuBar();
                menus.First.Checked = true;

                menus.Bar.Visible = false;

                CheckFalse(menus.First.Checked);
                CheckFalse(menus.Bar.Modal);
            }
        }

        public class PointerTests : TestFixture
        {
            private MouseManager manager;
            private MouseManagerTests.RecordingControl backdrop;
            private TwoMenuBar menus;

            public override void TestSetup()
            {
                manager = new MouseManager();
                backdrop = new MouseManagerTests.RecordingControl("backdrop")
                {
                    Handles = true,
                    Bounds = DropdownTests.ScreenRect,
                };
                menus = new TwoMenuBar();

                manager.Controls.Add(backdrop);
                manager.Controls.Add(menus.Bar);
            }

            [IgnoreTest]
            private void Click(Vector position)
            {
                manager.MouseDown(At(position), MouseButtonFlags.Left);
                manager.MouseUp(At(position), MouseButtonFlags.Left);
            }

            [IgnoreTest]
            private void OpenTheFirstMenu()
            {
                Click(OnTheFirstHeader);
                DropdownTests.Walk(menus.Bar);
            }

            public void ClickingAHeader_OpensItsMenu()
            {
                Click(OnTheFirstHeader);

                CheckTrue(menus.First.Checked);
            }

            public void ClickingTheOpenHeader_ClosesIt()
            {
                OpenTheFirstMenu();

                Click(OnTheFirstHeader);

                CheckFalse(menus.First.Checked);
            }

            public void PointingAtAnotherHeaderWhileOneIsOpen_SwitchesToIt()
            {
                OpenTheFirstMenu();

                manager.MouseMove(At(OnTheSecondHeader));

                CheckFalse(menus.First.Checked);
                CheckTrue(menus.Second.Checked);
            }

            public void PointingAtAHeaderWhileNoneIsOpen_OpensNothing()
            {
                manager.MouseMove(At(OnTheSecondHeader));

                CheckFalse(menus.Second.Checked);
            }

            public void PressingAwayWhileOpen_ClosesItWithoutReachingBeneath()
            {
                OpenTheFirstMenu();

                manager.MouseDown(At(AwayFromEverything), MouseButtonFlags.Left);

                CheckFalse(menus.First.Checked);
                CheckEqual(0, backdrop.MouseDownCount);
            }

            public void ClickingAnItem_ClosesTheMenuAndRaisesItsIndex()
            {
                OpenTheFirstMenu();
                int raisedWith = -1;
                menus.First.OnItemClicked += index => raisedWith = index;

                Click(OnTheFirstMenusFirstItem);

                CheckEqual(0, raisedWith);
                CheckFalse(menus.First.Checked);
            }

            public void WhileClosed_PressesReachWhatIsBeneath()
            {
                CheckEqual(backdrop, manager.MouseDown(At(AwayFromEverything), MouseButtonFlags.Left));
            }
        }
    }
}