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

namespace Glass.UnitTests
{
    public class GroupBoxRenderingTests : TestFixture
    {
        public static readonly Rect Whole = Rect.FromPositionAndSize(Vector.Zero, new Vector(100, 60));

        // No caption style, so the frame fills the rect and the gap begins after the 4 wide corner and the offset.
        public static GroupBoxMaterial Framed()
        {
            return new GroupBoxMaterial
            {
                Background = null,
                Frame = GroupBoxMaterialTests.Cornered(),
                CaptionOffset = 20,
            };
        }

        public static RendererTests.TestRenderer Rendered(GroupBoxMaterial material, Rect rect, int gapWidth = 0)
        {
            var renderer = new RendererTests.TestRenderer();
            renderer.Render(7, material, rect,
                new DrawState { MaterialState = new GroupBox.GapState { Width = gapWidth } });

            return renderer;
        }

        public static List<Rect> Clips(RendererTests.TestRenderer renderer)
        {
            return renderer.renderCalls.Select(call => call.clipWindow.Value.BoundingBox).Distinct().ToList();
        }

        public class BackgroundTests : TestFixture
        {
            public void FillsTheWholeRect()
            {
                var background = new SolidColorMaterial { Color = Colors.Blue };

                RendererTests.TestRenderer renderer = Rendered(new GroupBoxMaterial
                {
                    Frame = null,
                    Background = background,
                }, Whole);

                CheckEqual(1, renderer.renderCalls.Count);
                CheckTrue(ReferenceEquals(background, renderer.renderCalls[0].material));
                CheckEqual(Whole, renderer.renderCalls[0].rect);
            }

            public void ZeroSizedRect_DrawsNothing()
            {
                var material = Framed() with { Background = new SolidColorMaterial() };

                Rect empty = Rect.FromPositionAndSize(Vector.Zero, new Vector(0, 60));

                CheckEqual(0, Rendered(material, empty).renderCalls.Count);
            }

            public void NoBackgroundAndNoFrame_DrawsNothing()
            {
                CheckEqual(0, Rendered(new GroupBoxMaterial
                {
                    Background = null,
                    Frame = null,
                }, Whole).renderCalls.Count);
            }

            public void IsDrawnBeforeTheFrame()
            {
                var background = new SolidColorMaterial { Color = Colors.Blue };

                RendererTests.TestRenderer renderer = Rendered(Framed() with { Background = background }, Whole);

                CheckEqual(9, renderer.renderCalls.Count);
                CheckTrue(ReferenceEquals(background, renderer.renderCalls[0].material));
            }
        }

        public class FrameTests : TestFixture
        {
            public void NoGap_DrawsTheFrameWhole()
            {
                RendererTests.TestRenderer renderer = Rendered(Framed(), Whole);

                CheckEqual(8, renderer.renderCalls.Count);
                CheckTrue(renderer.renderCalls.All(call => call.clipWindow == null));
            }

            public void IsDrawnInsideTheFrameInset()
            {
                RendererTests.TestRenderer renderer = Rendered(Framed() with { FrameInset = 5 }, Whole);

                CheckEqual(8, renderer.renderCalls.Count);
                CheckEqual(5, renderer.renderCalls.Min(call => call.rect.Left));
                CheckEqual(95, renderer.renderCalls.Max(call => call.rect.Right));
                CheckEqual(55, renderer.renderCalls.Max(call => call.rect.Bottom));
            }

            public void NoFrame_DrawsNothing()
            {
                RendererTests.TestRenderer renderer = Rendered(
                    new GroupBoxMaterial { Background = null, Frame = null, CaptionOffset = 20 }, Whole, gapWidth: 30);

                CheckEqual(0, renderer.renderCalls.Count);
            }

            public void ZeroSizedRect_DrawsNothing()
            {
                Rect empty = Rect.FromPositionAndSize(Vector.Zero, new Vector(100, 0));

                CheckEqual(0, Rendered(Framed(), empty, gapWidth: 30).renderCalls.Count);
            }

            public void Gap_DrawsTheFrameBehindThreeClips()
            {
                RendererTests.TestRenderer renderer = Rendered(Framed(), Whole, gapWidth: 30);

                CheckEqual(24, renderer.renderCalls.Count);
                CheckEqual(3, Clips(renderer).Count);
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(Vector.Zero, new Vector(24, 60))));
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(54, 0), new Vector(46, 60))));
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(24, 2), new Vector(30, 58))));
            }

            public void Gap_RunningPastTheRightEdge_DropsTheRightClip()
            {
                RendererTests.TestRenderer renderer = Rendered(Framed(), Whole, gapWidth: 90);

                CheckEqual(2, Clips(renderer).Count);
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(Vector.Zero, new Vector(24, 60))));
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(24, 2), new Vector(76, 58))));
            }

            public void Gap_StaysInsideTheClipItIsDrawnUnder()
            {
                var renderer = new RendererTests.TestRenderer();
                var drawState = new DrawState
                {
                    ClipWindow = Rect.FromPositionAndSize(new Vector(10, 0), new Vector(20, 60)),
                    MaterialState = new GroupBox.GapState { Width = 30 },
                };

                renderer.Render(7, Framed(), Whole, drawState);

                CheckEqual(2, Clips(renderer).Count);
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(10, 0), new Vector(14, 60))));
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(24, 2), new Vector(6, 58))));
            }

            public void Scale_ScalesTheGapAndTheClips()
            {
                RendererTests.TestRenderer renderer = Rendered(Framed() with { Scale = 2 }, Whole, gapWidth: 30);

                CheckEqual(3, Clips(renderer).Count);
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(Vector.Zero, new Vector(24, 30))));
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(39, 0), new Vector(11, 30))));
                CheckTrue(Clips(renderer).Contains(Rect.FromPositionAndSize(new Vector(24, 2), new Vector(15, 28))));
            }
        }

        public class TintTests : TestFixture
        {
            public void ReachesTheBackgroundAndTheFrame()
            {
                var material = Framed() with { Background = new SolidColorMaterial(), TintColor = Colors.Red };

                RendererTests.TestRenderer renderer = Rendered(material, Whole, gapWidth: 30);

                CheckEqual(25, renderer.renderCalls.Count);
                CheckTrue(renderer.renderCalls.All(call => call.tintColor == Colors.Red));
            }

            public void FramesOwnTint_WinsOverTheMaterials()
            {
                var material = new GroupBoxMaterial
                {
                    Background = null,
                    Frame = GroupBoxMaterialTests.Cornered() with { TintColor = Colors.Green },
                    TintColor = Colors.Red,
                };

                RendererTests.TestRenderer renderer = Rendered(material, Whole);

                CheckTrue(renderer.renderCalls.All(call => call.tintColor == Colors.Green));
            }
        }

        public class StateTests : TestFixture
        {
            public void DrawnWithoutAGapState_Throws()
            {
                var renderer = new RendererTests.TestRenderer();

                CheckThrow(typeof(System.InvalidOperationException));
                renderer.Render(7, Framed(), Whole, new DrawState());
            }
        }
    }
}