using Annulus;
using Azimuth;
using System;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class MenuButtonTests : TestFixture
    {
        public static readonly Material NarrowLabel = DropdownTests.NarrowLabel;

        public static readonly Material WideLabel = DropdownTests.WideLabel;

        public static readonly Rect HeaderBounds = DropdownTests.DropdownBounds;

        public static readonly Vector OnTheHeader = new Vector(120, 210);

        public static readonly Vector OffTheHeader = new Vector(700, 500);

        public static MenuButton NewMenuButton()
        {
            var menuButton = new MenuButton { Bounds = HeaderBounds };
            menuButton.Popup.ScrollViewMaterial = ScrollViewTests.WithBars(DropdownPopupTests.Thickness);
            menuButton.Rebuild(new[] { NarrowLabel, WideLabel });
            return menuButton;
        }

        /// <summary>
        /// Two menus in one group, the first already open.
        /// </summary>
        public static (MenuButton open, MenuButton closed) TwoInAGroupWithTheFirstOpen()
        {
            var group = new RadioGroup();
            MenuButton open = NewMenuButton();
            MenuButton closed = NewMenuButton();
            open.Group = group;
            closed.Group = group;
            open.Checked = true;
            return (open, closed);
        }

        [IgnoreTest]
        public static Control[] Rows(MenuButton menuButton)
        {
            return DropdownPopupTests.Rows(menuButton.Popup);
        }

        public class CtorTests : TestFixture
        {
            public void Always_StartsUncheckedWithItsPopupClosed()
            {
                var menuButton = new MenuButton();

                CheckFalse(menuButton.Checked);
                CheckFalse(menuButton.Popup.IsOpen);
            }

            public void Always_HasANonModalPopup()
            {
                CheckFalse(new MenuButton().Popup.Modal);
            }

            public void Always_HoldsThePopupBeneathItself()
            {
                var menuButton = new MenuButton();
                bool foundPopup = false;

                foreach (Control child in menuButton.DirectChildren.BackToFront())
                {
                    foundPopup = foundPopup || child == menuButton.Popup;
                }

                CheckTrue(foundPopup);
            }
        }

        public class CheckedTests : TestFixture
        {
            public void Setting_OpensThePopup()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.Checked = true;

                CheckTrue(menuButton.Popup.IsOpen);
            }

            public void Clearing_ClosesThePopup()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;

                menuButton.Checked = false;

                CheckFalse(menuButton.Popup.IsOpen);
            }

            public void SettingAnotherInTheGroup_ClosesThisOnesPopup()
            {
                (MenuButton open, MenuButton closed) = TwoInAGroupWithTheFirstOpen();

                closed.Checked = true;

                CheckFalse(open.Popup.IsOpen);
                CheckTrue(closed.Popup.IsOpen);
            }

            public void Setting_ShowsThePopupBelowOnTheNextUpdate()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;

                DropdownTests.Walk(menuButton);

                CheckTrue(menuButton.Popup.Visible);
                CheckEqual(HeaderBounds.Left, menuButton.Popup.Bounds.Left);
                CheckEqual(HeaderBounds.Bottom, menuButton.Popup.Bounds.Top);
            }
        }

        public class ToggleTests : TestFixture
        {
            public void Unchecked_Checks()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.Toggle();

                CheckTrue(menuButton.Checked);
            }

            public void Checked_Unchecks()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;

                menuButton.Toggle();

                CheckFalse(menuButton.Checked);
            }
        }

        public class ClickTests : TestFixture
        {
            public void Closed_OpensItAndClaimsTheEvent()
            {
                MenuButton menuButton = NewMenuButton();

                CheckTrue(menuButton.Click(DropdownPopupTests.At(OnTheHeader), MouseButtonFlags.Left));
                CheckTrue(menuButton.Checked);
            }

            public void Open_ClosesIt()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;

                menuButton.Click(DropdownPopupTests.At(OnTheHeader), MouseButtonFlags.Left);

                CheckFalse(menuButton.Checked);
            }

            public void Disabled_LeavesItClosedAndLetsTheEventThrough()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Enabled = false;

                CheckFalse(menuButton.Click(DropdownPopupTests.At(OnTheHeader), MouseButtonFlags.Left));
                CheckFalse(menuButton.Checked);
            }
        }

        public class MouseMoveStartTests : TestFixture
        {
            public void OntoItWhileAGroupMateIsOpen_OpensThisOneInstead()
            {
                (MenuButton open, MenuButton closed) = TwoInAGroupWithTheFirstOpen();

                closed.MouseMoveStart(DropdownPopupTests.At(OnTheHeader));

                CheckTrue(closed.Checked);
                CheckFalse(open.Checked);
            }

            public void OntoItWhileNothingInTheGroupIsOpen_OpensNothing()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Group = new RadioGroup();

                menuButton.MouseMoveStart(DropdownPopupTests.At(OnTheHeader));

                CheckFalse(menuButton.Checked);
            }

            public void OntoItWithNoGroup_OpensNothing()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.MouseMoveStart(DropdownPopupTests.At(OnTheHeader));

                CheckFalse(menuButton.Checked);
            }

            public void OffIt_OpensNothing()
            {
                (MenuButton open, MenuButton closed) = TwoInAGroupWithTheFirstOpen();

                closed.MouseMoveStart(DropdownPopupTests.At(OffTheHeader));

                CheckFalse(closed.Checked);
                CheckTrue(open.Checked);
            }

            public void Disabled_OpensNothing()
            {
                (MenuButton open, MenuButton closed) = TwoInAGroupWithTheFirstOpen();
                closed.Enabled = false;

                closed.MouseMoveStart(DropdownPopupTests.At(OnTheHeader));

                CheckFalse(closed.Checked);
                CheckTrue(open.Checked);
            }
        }

        public class OnItemClickedTests : TestFixture
        {
            public void ClickingARow_RaisesItsIndex()
            {
                MenuButton menuButton = NewMenuButton();
                int raisedWith = -1;
                menuButton.OnItemClicked += index => raisedWith = index;

                Rows(menuButton)[1].Click(default, MouseButtonFlags.Left);

                CheckEqual(1, raisedWith);
            }

            public void ClickingARow_UnchecksItBeforeRaising()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;
                bool checkedWhenRaised = true;
                menuButton.OnItemClicked += _ => checkedWhenRaised = menuButton.Checked;

                Rows(menuButton)[0].Click(default, MouseButtonFlags.Left);

                CheckFalse(checkedWhenRaised);
                CheckFalse(menuButton.Popup.IsOpen);
            }

            public void ClickingARow_ClearsItsGroup()
            {
                (MenuButton open, MenuButton _) = TwoInAGroupWithTheFirstOpen();

                Rows(open)[0].Click(default, MouseButtonFlags.Left);

                CheckNull(open.Group.Selected);
            }
        }

        public class RebuildTests : TestFixture
        {
            public void Always_BuildsOneRowPerLabelInOrder()
            {
                var menuButton = new MenuButton { Bounds = HeaderBounds };

                menuButton.Rebuild(new[] { NarrowLabel, WideLabel });

                Control[] rows = Rows(menuButton);
                CheckEqual(2, rows.Length);
                CheckEqual(NarrowLabel, DropdownTests.LabelMaterialOf(rows[0]));
                CheckEqual(WideLabel, DropdownTests.LabelMaterialOf(rows[1]));
            }

            public void EmptyList_ClearsTheRows()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.Rebuild(Array.Empty<Material>());

                CheckEqual(0, menuButton.Popup.CanvasChildren.Count);
            }

            public void Null_Throws()
            {
                MenuButton menuButton = NewMenuButton();

                CheckThrow(typeof(ArgumentNullException));
                menuButton.Rebuild(null);
            }

            public void GenericOverload_MapsEachItemThroughLabelForInOrder()
            {
                var menuButton = new MenuButton { Bounds = HeaderBounds };

                menuButton.Rebuild(new[] { "first", "second" }, item => item == "first" ? NarrowLabel : WideLabel);

                Control[] rows = Rows(menuButton);
                CheckEqual(NarrowLabel, DropdownTests.LabelMaterialOf(rows[0]));
                CheckEqual(WideLabel, DropdownTests.LabelMaterialOf(rows[1]));
            }

            public void GenericOverload_NullItems_Throws()
            {
                MenuButton menuButton = NewMenuButton();

                CheckThrow(typeof(ArgumentNullException));
                menuButton.Rebuild<string>(null, item => NarrowLabel);
            }

            public void GenericOverload_NullLabelFor_Throws()
            {
                MenuButton menuButton = NewMenuButton();

                CheckThrow(typeof(ArgumentNullException));
                menuButton.Rebuild(new[] { "first" }, null);
            }
        }

        public class SelectedIndexTests : TestFixture
        {
            public void Setting_SelectsThatRowInThePopup()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.SelectedIndex = 1;

                CheckEqual(1, menuButton.Popup.SelectedIndex);
            }

            public void Getting_ReadsThePopups()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.Popup.SelectedIndex = 1;

                CheckEqual(1, menuButton.SelectedIndex);
            }
        }

        public class BoundsTests : TestFixture
        {
            public void Setting_RelaysOutTheItemsToTheNewWidth()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.Bounds = DropdownPopupTests.Box(0, 0, 300, 40);

                CheckEqual(300, Rows(menuButton)[0].Bounds.Width);
            }
        }

        public class EnabledTests : TestFixture
        {
            public void Disabling_UnchecksIt()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;

                menuButton.Enabled = false;

                CheckFalse(menuButton.Checked);
                CheckFalse(menuButton.Popup.IsOpen);
            }

            public void Enabling_DoesNotRecheckIt()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;
                menuButton.Enabled = false;

                menuButton.Enabled = true;

                CheckFalse(menuButton.Checked);
            }

            public void Disabling_DisablesEachItem()
            {
                MenuButton menuButton = NewMenuButton();

                menuButton.Enabled = false;

                foreach (Control item in menuButton.Popup.CanvasChildren.BackToFront())
                {
                    CheckFalse(item.Enabled);
                }
            }

            public void Enabling_EnablesEachItemAgain()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Enabled = false;

                menuButton.Enabled = true;

                foreach (Control item in menuButton.Popup.CanvasChildren.BackToFront())
                {
                    CheckTrue(item.Enabled);
                }
            }
        }

        public class VisibleTests : TestFixture
        {
            public void Hiding_UnchecksIt()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;

                menuButton.Visible = false;

                CheckFalse(menuButton.Checked);
                CheckFalse(menuButton.Popup.IsOpen);
            }

            public void Showing_DoesNotRecheckIt()
            {
                MenuButton menuButton = NewMenuButton();
                menuButton.Checked = true;
                menuButton.Visible = false;

                menuButton.Visible = true;

                CheckFalse(menuButton.Checked);
            }
        }
    }
}