using UnitTestSharp;
using Azimuth;
using Annulus;
using System.Collections.Generic;

namespace Glass.UnitTests
{
    public class WindowTests : TestFixture
    {
        /// <summary>
        /// With no materials and the default 24-tall title bar: a 200x24 title bar (close button taking its last 24,
        /// caption the other 176) over a 200x126 content area.  The resize band is hit-test only, so it never
        /// shrinks this.
        /// </summary>
        public static readonly Rect StandardBounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(200, 150));

        public static readonly Vector OnTheTitleBar = new Vector(50, 15);

        public static readonly Vector OnTheContent = new Vector(50, 80);

        public static readonly Vector OnTheCloseButton = new Vector(180, 15);

        [IgnoreTest]
        private static Window StandardWindow()
        {
            return new Window { Bounds = StandardBounds };
        }

        [IgnoreTest]
        private static List<Control> OrderOf(ControlContainer controls)
        {
            return ControlContainerTests.BackToFrontOrderOf(controls);
        }

        public class CtorTests : TestFixture
        {
            public void Always_MovesToFrontOnClick()
            {
                CheckTrue(new Window().MoveToFrontOnClick);
            }

            public void Always_HasJustTheTitleBarAndContentAsDirectChildren()
            {
                CheckEqual(2, OrderOf(new Window().DirectChildren).Count);
            }
        }

        public class CanvasChildrenTests : TestFixture
        {
            public void AddedChildren_StayOutOfDirectChildren()
            {
                var window = new Window();
                var child = window.CanvasChildren.Add(new Control("child"));

                CheckFalse(OrderOf(window.DirectChildren).Contains(child));
                CheckEqual(2, OrderOf(window.DirectChildren).Count);
            }
        }

        public class ContentSizeTests : TestFixture
        {
            public void Standard_IsTheCanvasBelowTheTitleBar()
            {
                CheckEqual(new Vector(200, 126), StandardWindow().ContentSize);
            }
        }

        public class CaptionTests : TestFixture
        {
            public void Standard_FillsTheTitleBarLeftOfTheCloseButton()
            {
                CheckEqual(Rect.FromPositionAndSize(Vector.Zero, new Vector(176, 24)), StandardWindow().Caption.Bounds);
            }
        }

        public class CloseButtonTests : TestFixture
        {
            public void Standard_IsASquareAtTheRightEndOfTheTitleBar()
            {
                CheckEqual(
                    Rect.FromPositionAndSize(new Vector(176, 0), new Vector(24, 24)),
                    StandardWindow().CloseButton.Bounds);
            }

            public void Clicked_ClosesTheWindow()
            {
                var manager = new MouseManager();
                Window window = manager.Controls.Add(StandardWindow());

                manager.MouseDown(new MouseState { Position = OnTheCloseButton }, MouseButtonFlags.Left);
                manager.MouseUp(new MouseState { Position = OnTheCloseButton }, MouseButtonFlags.Left);

                CheckFalse(window.Visible);
            }
        }

        public class TitleBarHeightTests : TestFixture
        {
            public void ByDefault_Is24()
            {
                CheckEqual(24, new Window().TitleBarHeight);
            }

            public void Changed_LaysTheTitleBarAndContentOutAgain()
            {
                Window window = StandardWindow();

                window.TitleBarHeight = 30;

                CheckEqual(Rect.FromPositionAndSize(Vector.Zero, new Vector(170, 30)), window.Caption.Bounds);
                CheckEqual(new Vector(200, 120), window.ContentSize);
            }
        }

        public class ShowTitleBarTests : TestFixture
        {
            public void ByDefault_IsTrue()
            {
                CheckTrue(new Window().ShowTitleBar);
            }

            public void Off_GivesTheContentTheWholeCanvas()
            {
                Window window = StandardWindow();

                window.ShowTitleBar = false;

                CheckEqual(new Vector(200, 150), window.ContentSize);
            }

            public void BackOn_TakesTheTitleBarsSpaceBack()
            {
                Window window = StandardWindow();
                window.ShowTitleBar = false;

                window.ShowTitleBar = true;

                CheckEqual(new Vector(200, 126), window.ContentSize);
            }
        }

        public class ShowCloseButtonTests : TestFixture
        {
            public void ByDefault_IsTrue()
            {
                CheckTrue(new Window().ShowCloseButton);
            }

            public void Off_HidesTheButtonAndGivesItsSpaceToTheCaption()
            {
                Window window = StandardWindow();

                window.ShowCloseButton = false;

                CheckFalse(window.CloseButton.Visible);
                CheckEqual(Rect.FromPositionAndSize(Vector.Zero, new Vector(200, 24)), window.Caption.Bounds);
            }
        }

        public class MaterialTests : TestFixture
        {
            public void Changed_LaysTheContentOutAgain()
            {
                Window window = StandardWindow();

                window.Material = new Material { BorderSize = new Rect.BorderSize(10) };

                CheckEqual(new Vector(180, 106), window.ContentSize);
            }
        }

        public class WindowMaterialTests : TestFixture
        {
            public void Set_ComesBackFromTheParts()
            {
                var set = new WindowMaterial
                {
                    Background = new Material { BorderSize = new Rect.BorderSize(1) },
                    TitleBar = new Material { BorderSize = new Rect.BorderSize(2) },
                    Content = new Material { BorderSize = new Rect.BorderSize(3) },
                    CloseButton = new ButtonMaterial
                    {
                        NominalMaterial = new Material { BorderSize = new Rect.BorderSize(4) },
                    },
                };
                var window = new Window { WindowMaterial = set };

                WindowMaterial gotten = window.WindowMaterial;

                CheckEqual(set.Background, gotten.Background);
                CheckEqual(set.TitleBar, gotten.TitleBar);
                CheckEqual(set.Content, gotten.Content);
                CheckEqual(set.CloseButton, gotten.CloseButton);
            }

            public void Set_LaysTheContentOutAgain()
            {
                Window window = StandardWindow();

                window.WindowMaterial = new WindowMaterial
                {
                    Content = new Material { BorderSize = new Rect.BorderSize(2) },
                };

                CheckEqual(new Vector(196, 122), window.ContentSize);
            }
        }

        public class OnContentResizedTests : TestFixture
        {
            public void Resized_RaisesWithTheNewContentSize()
            {
                Window window = StandardWindow();
                Vector? raised = null;
                window.OnContentResized += contentSizeNow => raised = contentSizeNow;

                window.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(220, 150));

                CheckEqual(new Vector(220, 126), raised);
            }

            public void TitleBarHidden_Raises()
            {
                Window window = StandardWindow();
                Vector? raised = null;
                window.OnContentResized += contentSizeNow => raised = contentSizeNow;

                window.ShowTitleBar = false;

                CheckEqual(new Vector(200, 150), raised);
            }

            public void Moved_DoesNotRaise()
            {
                Window window = StandardWindow();
                bool raised = false;
                window.OnContentResized += _ => raised = true;

                window.Bounds = Rect.FromPositionAndSize(new Vector(30, 40), StandardBounds.Size);

                CheckFalse(raised);
            }
        }

        public class OnResizedTests : TestFixture
        {
            public void CallersHandler_SeesTheContentAlreadyLaidOut()
            {
                Window window = StandardWindow();
                Vector? seen = null;
                window.OnResized += _ => seen = window.ContentSize;

                window.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(220, 150));

                CheckEqual(new Vector(220, 126), seen);
            }
        }

        public class CloseTests : TestFixture
        {
            public void Visible_HidesTheWindow()
            {
                Window window = StandardWindow();

                window.Close();

                CheckFalse(window.Visible);
            }

            public void Visible_RaisesOnClosedWithTheWindow()
            {
                Window window = StandardWindow();
                Window closed = null;
                window.OnClosed += which => closed = which;

                window.Close();

                CheckEqual(window, closed);
            }

            public void AlreadyHidden_DoesNotRaiseOnClosed()
            {
                Window window = StandardWindow();
                window.Visible = false;
                bool raised = false;
                window.OnClosed += _ => raised = true;

                window.Close();

                CheckFalse(raised);
            }
        }

        public class MinContentSizeTests : TestFixture
        {
            public void ByDefault_IsZero()
            {
                CheckEqual(Vector.Zero, new Window().MinContentSize);
            }
        }

        public class MinSizeTests : TestFixture
        {
            public void ByDefault_IsZero()
            {
                CheckEqual(Vector.Zero, new Window().MinSize);
            }

            public void SetSmallerThanTheChrome_StillReadsBackExactly()
            {
                var window = new Window { MinSize = new Vector(1, 1) };

                CheckEqual(new Vector(1, 1), window.MinSize);
            }
        }

        public class EffectiveMinSizeTests : TestFixture
        {
            public void ByDefault_FitsTheCloseButtonAcrossTheTitleBar()
            {
                CheckEqual(new Vector(24, 24), new Window().EffectiveMinSize);
            }

            public void TitleBarHidden_IsZero()
            {
                CheckEqual(Vector.Zero, new Window { ShowTitleBar = false }.EffectiveMinSize);
            }

            public void CloseButtonHidden_NeedsNoWidthForIt()
            {
                CheckEqual(new Vector(0, 24), new Window { ShowCloseButton = false }.EffectiveMinSize);
            }

            public void MinContentSize_AddsBelowTheTitleBar()
            {
                CheckEqual(new Vector(50, 64), new Window { MinContentSize = new Vector(50, 40) }.EffectiveMinSize);
            }

            public void SetLargerThanTheChrome_Wins()
            {
                CheckEqual(new Vector(100, 90), new Window { MinSize = new Vector(100, 90) }.EffectiveMinSize);
            }

            public void SetSmallerThanTheChrome_TheChromeStillWins()
            {
                CheckEqual(new Vector(24, 24), new Window { MinSize = new Vector(1, 1) }.EffectiveMinSize);
            }

            public void ResizeDrag_StopsWhereTheTitleBarWouldBeCut()
            {
                Window window = StandardWindow();
                window.MouseDown(new MouseState { Position = new Vector(100, 148) }, MouseButtonFlags.Left);

                window.MouseMove(new MouseState { Position = new Vector(100, -1000) });

                CheckEqual(new Vector(200, 24), window.Bounds.Size);
            }
        }

        public class IsDragHandleTests : TestFixture
        {
            public void OnTheTitleBar_IsTrue()
            {
                CheckTrue(StandardWindow().IsDragHandle(OnTheTitleBar));
            }

            public void OnTheContent_IsFalse()
            {
                CheckFalse(StandardWindow().IsDragHandle(OnTheContent));
            }

            public void TitleBarHidden_IsFalseWhereItWouldBe()
            {
                Window window = StandardWindow();
                window.ShowTitleBar = false;

                CheckFalse(window.IsDragHandle(OnTheTitleBar));
            }
        }

        public class MouseDownTests : TestFixture
        {
            public void DraggedByTheTitleBar_Moves()
            {
                var manager = new MouseManager();
                Window window = manager.Controls.Add(StandardWindow());

                manager.MouseDown(new MouseState { Position = OnTheTitleBar }, MouseButtonFlags.Left);
                manager.MouseMove(new MouseState { Position = OnTheTitleBar + new Vector(30, 40) });

                CheckEqual(Rect.FromPositionAndSize(new Vector(30, 40), StandardBounds.Size), window.Bounds);
            }

            public void OnTheContent_ClaimsThePressAndMovesToTheFront()
            {
                var manager = new MouseManager();
                Window window = manager.Controls.Add(StandardWindow());
                var other = manager.Controls.Add(
                    new Control("other") { Bounds = Rect.FromPositionAndSize(new Vector(500, 500), new Vector(1, 1)) });

                Control claimed = manager.MouseDown(new MouseState { Position = OnTheContent }, MouseButtonFlags.Left);

                CheckEqual(window, claimed);
                CheckEqual(new Control[] { other, window }, OrderOf(manager.Controls));
            }
        }
    }
}