using Annulus;
using Azimuth;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class ScrollViewMaterialTests : TestFixture
    {
        [IgnoreTest]
        private static ScrollViewMaterial Bars()
        {
            return ScrollViewTests.WithBars(ScrollViewTests.Thickness);
        }

        [IgnoreTest]
        private static ScrollViewMaterial BorderedBars()
        {
            ScrollViewMaterial returnMe = Bars();
            returnMe.Background = ScrollViewTests.Bordered(border: 5, debugName: "background");
            returnMe.Canvas = ScrollViewTests.Bordered(border: 3, debugName: "canvas");
            return returnMe;
        }

        public class ScrollBarSizesTests : TestFixture
        {
            public void Both_IsEachBarsThickness()
            {
                CheckEqual(new Vector(20, 20), Bars().ScrollBarSizes(ScrollAxes.Both));
            }

            public void Vertical_TakesOnlyTheVerticalBarsWidth()
            {
                CheckEqual(new Vector(20, 0), Bars().ScrollBarSizes(ScrollAxes.Vertical));
            }

            public void Horizontal_TakesOnlyTheHorizontalBarsHeight()
            {
                CheckEqual(new Vector(0, 20), Bars().ScrollBarSizes(ScrollAxes.Horizontal));
            }

            public void None_IsZero()
            {
                CheckEqual(Vector.Zero, Bars().ScrollBarSizes(ScrollAxes.None));
            }

            public void EachStripUsesItsOwnBarsThickness()
            {
                var material = new ScrollViewMaterial
                {
                    HorizontalScrollBar = new ScrollBarMaterial
                    {
                        DecrementButton = new ScrollViewTests.SizedSolidMaterial(new Vector(30, 14)),
                    },
                    VerticalScrollBar = new ScrollBarMaterial
                    {
                        DecrementButton = new ScrollViewTests.SizedSolidMaterial(new Vector(20, 40)),
                    },
                };

                CheckEqual(new Vector(20, 14), material.ScrollBarSizes(ScrollAxes.Both));
            }
        }

        public class ViewportSizeForTests : TestFixture
        {
            public void TakesBothStripsOff()
            {
                CheckEqual(new Vector(180, 80), Bars().ViewportSizeFor(ScrollViewTests.ViewSize, ScrollAxes.Both));
            }

            public void AnAxisThatDoesNotScroll_TakesNoStripOffThatEdge()
            {
                CheckEqual(new Vector(180, 100),
                    Bars().ViewportSizeFor(ScrollViewTests.ViewSize, ScrollAxes.Vertical));
                CheckEqual(new Vector(200, 80),
                    Bars().ViewportSizeFor(ScrollViewTests.ViewSize, ScrollAxes.Horizontal));
            }

            public void NoAxes_TakesNoStripOffEitherEdge()
            {
                CheckEqual(new Vector(200, 100), Bars().ViewportSizeFor(ScrollViewTests.ViewSize, ScrollAxes.None));
            }

            public void StripLargerThanTheView_LeavesNothingRatherThanGoingNegative()
            {
                CheckEqual(new Vector(0, 80), Bars().ViewportSizeFor(new Vector(10, 100), ScrollAxes.Both));
            }

            public void Materials_TakeTheirBordersOffAroundTheStrips()
            {
                // 200x100 less the background's 10, less the 20px strips, less the canvas's 6.
                CheckEqual(new Vector(164, 64),
                    BorderedBars().ViewportSizeFor(ScrollViewTests.ViewSize, ScrollAxes.Both));
            }

            public void IsTheInverseOfBoundsSizeFor()
            {
                ScrollViewMaterial material = BorderedBars();
                var viewportSize = new Vector(100, 200);

                Vector boundsSize = material.BoundsSizeFor(viewportSize, ScrollAxes.Both);

                CheckEqual(viewportSize, material.ViewportSizeFor(boundsSize, ScrollAxes.Both));
            }
        }

        public class BoundsSizeForTests : TestFixture
        {
            public void AddsBothScrollBarsToTheViewport()
            {
                CheckEqual(new Vector(200, 320), Bars().BoundsSizeFor(new Vector(180, 300), ScrollAxes.Both));
            }

            public void NoViewport_IsJustTheScrollBars()
            {
                CheckEqual(new Vector(20, 20), Bars().BoundsSizeFor(Vector.Zero, ScrollAxes.Both));
            }

            public void AnAxisThatDoesNotScroll_AddsNoScrollBarForIt()
            {
                CheckEqual(new Vector(180, 320), Bars().BoundsSizeFor(new Vector(180, 300), ScrollAxes.Horizontal));
                CheckEqual(new Vector(200, 300), Bars().BoundsSizeFor(new Vector(180, 300), ScrollAxes.Vertical));
            }

            public void NoAxes_AddsNoScrollBars()
            {
                CheckEqual(new Vector(180, 300), Bars().BoundsSizeFor(new Vector(180, 300), ScrollAxes.None));
            }

            public void Materials_ExpandTheViewportOutwardsThroughEachLayer()
            {
                // 100x200 plus the canvas's 6, plus the 20px scroll bars, plus the background's 10.
                CheckEqual(new Vector(136, 236), BorderedBars().BoundsSizeFor(new Vector(100, 200), ScrollAxes.Both));
            }

            public void BackgroundWithAMinimumSize_HoldsAtThatMinimum()
            {
                ScrollViewMaterial material = Bars();
                material.Background = new ScrollTrackTests.FixedSizeMaterial(new Vector(50, 60));

                CheckEqual(new Vector(50, 60), material.BoundsSizeFor(new Vector(10, 10), ScrollAxes.Both));
            }
        }
    }
}