using Amphora;
using Annulus;
using Azimuth;
using Clave;
using System;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class CheckboxDropdownTests : TestFixture
    {
        [IgnoreTest]
        public static CheckboxDropdown NewDropdown(out Checkbox[] checkboxes, int count = 2)
        {
            var returnMe = new CheckboxDropdown(ButtonBehavior.Default);

            checkboxes = new Checkbox[count];
            for (int index = 0; index < count; ++index)
            {
                checkboxes[index] = new Checkbox(ButtonBehavior.Default)
                {
                    Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(40, 10)),
                };
            }

            returnMe.Rebuild(checkboxes);

            return returnMe;
        }

        [IgnoreTest]
        public static Button RowOf(CheckboxDropdown dropdown, int index)
        {
            return (Button)DropdownPopupTests.Rows(dropdown.Popup)[index];
        }

        [IgnoreTest]
        public static void ClickRow(CheckboxDropdown dropdown, int index)
        {
            RowOf(dropdown, index).Click(default, MouseButtonFlags.Left, 1, NoKeys.Held, NoKeys.Manager);
        }

        public class CtorTests : TestFixture
        {
            public void Always_StartsClosed()
            {
                CheckFalse(new CheckboxDropdown(ButtonBehavior.Default).IsOpen);
            }

            public void Always_HoldsThePopupAsAChild()
            {
                var dropdown = new CheckboxDropdown(ButtonBehavior.Default);
                bool found = false;

                foreach (Control child in dropdown.CanvasChildren.BackToFront())
                {
                    found |= ReferenceEquals(dropdown.Popup, child);
                }

                CheckTrue(found);
            }
        }

        public class RebuildTests : TestFixture
        {
            public void WithCheckboxes_MakesARowForEach()
            {
                CheckboxDropdown dropdown = NewDropdown(out _, count: 3);

                CheckEqual(3, DropdownPopupTests.Rows(dropdown.Popup).Length);
            }

            public void WithNone_ClearsTheRows()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);

                dropdown.Rebuild(new Checkbox[0]);

                CheckEqual(0, DropdownPopupTests.Rows(dropdown.Popup).Length);
            }

            public void Again_TicksTheNewCheckboxesRatherThanTheOld()
            {
                CheckboxDropdown dropdown = NewDropdown(out Checkbox[] before, count: 1);
                var after = new Checkbox(ButtonBehavior.Default);
                dropdown.Rebuild(new[] { after });

                ClickRow(dropdown, 0);

                CheckTrue(after.Checked);
                CheckFalse(before[0].Checked);
            }

            public void WithNull_Throws()
            {
                var dropdown = new CheckboxDropdown(ButtonBehavior.Default);

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

        public class OpenTests : TestFixture
        {
            public void Always_OpensThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);

                dropdown.Open();

                CheckTrue(dropdown.IsOpen);
            }

            public void ActivatingTheButton_OpensThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);

                dropdown.Activate(NoKeys.Held, NoKeys.Manager);

                CheckTrue(dropdown.IsOpen);
            }
        }

        public class CloseTests : TestFixture
        {
            public void Always_ClosesThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Open();

                dropdown.Close();

                CheckFalse(dropdown.IsOpen);
            }
        }

        public class TickingTests : TestFixture
        {
            public void PressingARowsChrome_TicksItsCheckbox()
            {
                CheckboxDropdown dropdown = NewDropdown(out Checkbox[] checkboxes);

                ClickRow(dropdown, 1);

                CheckFalse(checkboxes[0].Checked);
                CheckTrue(checkboxes[1].Checked);
            }

            public void PressingARowsChromeAgain_UnticksIt()
            {
                CheckboxDropdown dropdown = NewDropdown(out Checkbox[] checkboxes);
                ClickRow(dropdown, 0);

                ClickRow(dropdown, 0);

                CheckFalse(checkboxes[0].Checked);
            }

            public void PressingARowsChrome_LeavesThePopupOpen()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Open();

                ClickRow(dropdown, 0);

                CheckTrue(dropdown.IsOpen);
            }

            public void ClickingACheckbox_LeavesThePopupOpen()
            {
                CheckboxDropdown dropdown = NewDropdown(out Checkbox[] checkboxes);
                dropdown.Open();

                checkboxes[0].Click(default, MouseButtonFlags.Left, 1, NoKeys.Held, NoKeys.Manager);

                CheckTrue(checkboxes[0].Checked);
                CheckTrue(dropdown.IsOpen);
            }
        }

        public class PressOutsideTests : TestFixture
        {
            public void Always_ClosesThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Open();
                DropdownPopupTests.Tick(dropdown.Popup, DropdownPopupTests.AnchorRect);

                dropdown.Popup.MouseDown(DropdownPopupTests.At(DropdownPopupTests.OutsideThePopup),
                    MouseButtonFlags.Left, NoKeys.Held, NoKeys.Manager);

                CheckFalse(dropdown.IsOpen);
            }
        }

        public class SizeChangedTests : TestFixture
        {
            public void Always_GivesThePopupTheButtonsWidthAsAMinimum()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);

                dropdown.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(75, 20));

                CheckEqual(75, dropdown.Popup.DropdownWidth);
            }
        }

        public class EnabledTests : TestFixture
        {
            public void WhenTurnedOff_ClosesAndDisablesThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Open();

                dropdown.Enabled = false;

                CheckFalse(dropdown.IsOpen);
                CheckFalse(dropdown.Popup.Enabled);
            }

            public void WhenTurnedBackOn_EnablesThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Enabled = false;

                dropdown.Enabled = true;

                CheckTrue(dropdown.Popup.Enabled);
            }
        }

        public class VisibleTests : TestFixture
        {
            public void WhenHidden_ClosesThePopup()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Open();

                dropdown.Visible = false;

                CheckFalse(dropdown.IsOpen);
            }

            public void WhenShownAgain_LeavesThePopupClosed()
            {
                CheckboxDropdown dropdown = NewDropdown(out _);
                dropdown.Visible = false;

                dropdown.Visible = true;

                CheckFalse(dropdown.IsOpen);
            }
        }
    }
}