using Annulus;
using Azimuth;
using Glass.Markdown;
using Glass.UnitTests.Materials;
using System;
using System.Collections.Generic;
using System.Linq;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class MarkdownViewTests : TestFixture
    {
        private const double Padding = 7;
        private const double BlockSpacing = 10;
        private const double HeadingSpacing = 20;
        private const double ItemSpacing = 3;
        private const double MarkerGap = 5;
        private const double RuleThickness = 2;

        // Every glyph is 3 wide and 4 tall, and with no margins a line of n characters measures exactly 3n by 4.
        public static readonly TextMaterialStyle Plain = new TextMaterialStyle
        {
            Font = TextMaterialTests.SharedMonospaceFont,
            VerticalMargin = 0,
            HorizontalMargin = 0,
        };

        private static readonly MarkdownStyle Style = new MarkdownStyle
        {
            Body = Plain,
            Padding = Padding,
            BlockSpacing = BlockSpacing,
            HeadingSpacing = HeadingSpacing,
            ItemSpacing = ItemSpacing,
            MarkerGap = MarkerGap,
            RuleThickness = RuleThickness,
        };

        private static MarkdownView NewView(string markdown, double width = 100, double height = 60,
            MarkdownStyle style = null, IReadOnlyDictionary<string, Material> images = null)
        {
            var view = new MarkdownView(markdown, style ?? Style, images);
            view.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(width, height));
            return view;
        }

        private static List<Control> ChildrenOf(MarkdownView view)
        {
            var returnMe = new List<Control>();
            foreach (Control child in view.CanvasChildren.BackToFront())
            {
                returnMe.Add(child);
            }

            return returnMe;
        }

        private static Label LabelWith(MarkdownView view, string text)
        {
            return ChildrenOf(view).OfType<Label>().Single(label => label.Text.ToString() == text);
        }

        private static Panel PanelNamed(MarkdownView view, string debugName)
        {
            return ChildrenOf(view).OfType<Panel>().Single(panel => panel.DebugName == debugName);
        }

        private static SpriteMaterial ImageOfSize(int width, int height)
        {
            var sheet = new SpriteSheetAttribute(width, height, 0, "x");
            return new SpriteMaterial(new Point(0, 0)) { SpriteSheet = sheet };
        }

        public class CtorTests : TestFixture
        {
            public void NullBlocksThrow()
            {
                CheckThrow(typeof(ArgumentNullException));
                new MarkdownView((IReadOnlyList<MarkdownBlock>)null, Style);
            }

            public void NullMarkdownThrows()
            {
                CheckThrow(typeof(ArgumentNullException));
                new MarkdownView((string)null, Style);
            }

            public void NullStyleThrows()
            {
                CheckThrow(typeof(ArgumentNullException));
                new MarkdownView("text", null);
            }

            public void AStyleWithoutABodyThrows()
            {
                CheckThrow(typeof(ArgumentException));
                new MarkdownView("text", new MarkdownStyle());
            }

            public void AnImageTheDocumentNamesAndTheImagesLackThrows()
            {
                CheckThrow(typeof(ArgumentException));
                new MarkdownView("![alt](missing.png)", Style);
            }

            public void AnImageNotAmongTheImagesGivenThrows()
            {
                var images = new Dictionary<string, Material> { ["other.png"] = ImageOfSize(1, 1) };

                CheckThrow(typeof(ArgumentException));
                new MarkdownView("![alt](missing.png)", Style, images);
            }

            public record UnknownBlock : MarkdownBlock;

            public void ABlockOfAKindItDoesNotKnowThrows()
            {
                CheckThrow(typeof(ArgumentException));
                new MarkdownView(new MarkdownBlock[] { new UnknownBlock() }, Style);
            }

            public void BlocksGivenDirectlyAreShown()
            {
                var view = new MarkdownView(new MarkdownBlock[] { new MarkdownParagraph("abcd") }, Style);
                view.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(100, 60));

                CheckEqual(new Vector(Padding, Padding), LabelWith(view, "abcd").Bounds.TopLeft);
            }

            public void DoesNotScrollSideways()
            {
                CheckFalse(NewView("text").ScrollsHorizontally);
            }

            public void ScrollsUpAndDown()
            {
                CheckTrue(NewView("text").ScrollsVertically);
            }

            public void NoBlocksStillMakesAView()
            {
                MarkdownView view = NewView(string.Empty);

                CheckEqual(0, view.Headings.Count);
            }
        }

        public class HeadingsTests : TestFixture
        {
            public void ListsTheHeadingsInOrder()
            {
                MarkdownView view = NewView("# One\n\ntext\n\n## Two\n\n- item\n\n### Three");

                CheckEqual(
                    new[]
                    {
                        new MarkdownHeading(1, "One"), new MarkdownHeading(2, "Two"), new MarkdownHeading(3, "Three"),
                    },
                    view.Headings);
            }

            public void IsEmptyWithoutHeadings()
            {
                CheckEqual(0, NewView("just text").Headings.Count);
            }
        }

        public class ReflowTests : TestFixture
        {
            public void ParagraphsStartAtThePadding()
            {
                MarkdownView view = NewView("abcd");

                CheckEqual(new Vector(Padding, Padding), LabelWith(view, "abcd").Bounds.TopLeft);
            }

            public void ParagraphsFillTheWidthWithinThePadding()
            {
                MarkdownView view = NewView("abcd", width: 100);

                CheckEqual(100 - 2 * Padding, LabelWith(view, "abcd").Bounds.Width);
            }

            public void AParagraphWrapsToTheWidth()
            {
                // 24 wide takes eight characters, so "aaaa bbbb" does not fit and wraps.
                MarkdownView view = NewView("aaaa bbbb", width: 24 + 2 * Padding);

                CheckEqual(8, LabelWith(view, "aaaa bbbb").Bounds.Height);
            }

            public void AParagraphThatFitsIsOneLine()
            {
                MarkdownView view = NewView("aaaa bbbb", width: 100);

                CheckEqual(4, LabelWith(view, "aaaa bbbb").Bounds.Height);
            }

            public void BlocksStackWithTheBlockSpacingBetween()
            {
                MarkdownView view = NewView("one\n\ntwo");

                Rect first = LabelWith(view, "one").Bounds;
                Rect second = LabelWith(view, "two").Bounds;

                CheckEqual(first.Bottom + BlockSpacing, second.Top);
            }

            public void AHeadingHasTheHeadingSpacingAbove()
            {
                MarkdownView view = NewView("text\n\n# Title");

                CheckEqual(
                    LabelWith(view, "text").Bounds.Bottom + HeadingSpacing, LabelWith(view, "Title").Bounds.Top);
            }

            public void TheFirstBlockHasNoSpaceAbove()
            {
                MarkdownView view = NewView("# Title");

                CheckEqual((Scalar)Padding, LabelWith(view, "Title").Bounds.Top);
            }

            public void ItemsStackWithTheItemSpacingBetween()
            {
                MarkdownView view = NewView("- one\n- two");

                CheckEqual(LabelWith(view, "one").Bounds.Bottom + ItemSpacing, LabelWith(view, "two").Bounds.Top);
            }

            public void AParagraphAfterItemsHasTheBlockSpacing()
            {
                MarkdownView view = NewView("- one\n\nafter");

                CheckEqual(LabelWith(view, "one").Bounds.Bottom + BlockSpacing, LabelWith(view, "after").Bounds.Top);
            }

            public void BulletsAreDots()
            {
                MarkdownView view = NewView("- one");

                CheckEqual("•", LabelWith(view, "•").Text.ToString());
            }

            public void NumbersAreShownAsWritten()
            {
                MarkdownView view = NewView("1. one\n\n12. twelve\n\n3. three");

                CheckEqual(
                    new[] { "1.", "12.", "3." },
                    ChildrenOf(view).OfType<Label>()
                        .Select(label => label.Text.ToString()).Where(text => text.EndsWith(".")).ToArray());
            }

            public void ItemTextStartsAfterTheWidestMarkerAndTheGap()
            {
                // "12." is 9 wide against 6 for "1.", and every item's text starts after the widest.
                MarkdownView view = NewView("1. one\n\n12. twelve");

                CheckEqual((Scalar)(Padding + 9 + MarkerGap), LabelWith(view, "one").Bounds.Left);
                CheckEqual((Scalar)(Padding + 9 + MarkerGap), LabelWith(view, "twelve").Bounds.Left);
            }

            public void MarkersAlignOnTheirRightEdge()
            {
                MarkdownView view = NewView("1. one\n\n12. twelve");

                CheckEqual((Scalar)(Padding + 9 - 6), LabelWith(view, "1.").Bounds.Left);
                CheckEqual((Scalar)Padding, LabelWith(view, "12.").Bounds.Left);
            }

            public void ItemTextWrapsToWhatTheMarkerLeaves()
            {
                // The text column is 100 - 14 - 9 - 5 = 72 wide, which is 24 characters.
                string text = new string('a', 20) + " " + new string('b', 20);
                MarkdownView view = NewView("12. " + text);

                CheckEqual(8, LabelWith(view, text).Bounds.Height);
            }

            public void ARuleSpansTheWidthAtTheRuleThickness()
            {
                MarkdownView view = NewView("---");

                Rect expected = Rect.FromPositionAndSize(
                    new Vector(Padding, Padding), new Vector(100 - 2 * Padding, RuleThickness));

                CheckEqual(expected, PanelNamed(view, "markdown rule").Bounds);
            }

            public void ACodeBlockHasABackgroundBehindItsText()
            {
                MarkdownView view = NewView("```\nab\ncd\n```");

                Panel background = PanelNamed(view, "markdown code background");

                CheckEqual(LabelWith(view, "ab\ncd").Bounds, background.Bounds);
                CheckEqual(8, background.Bounds.Height);
            }

            public void ACodeBlockUsesTheCodeStyleWhenGiven()
            {
                TextMaterialStyle code = Plain with { Font = TextMaterialTests.CreateMonospaceTestFont(5, 6) };
                MarkdownView view = NewView("```\nab\n```", style: Style with { Code = code });

                CheckEqual(new Vector(100 - 2 * Padding, 6), LabelWith(view, "ab").Bounds.Size);
            }

            public void AnImageKeepsItsSizeWhenItFits()
            {
                var images = new Dictionary<string, Material> { ["a.png"] = ImageOfSize(20, 10) };
                MarkdownView view = NewView("![alt](a.png)", width: 100, images: images);

                CheckEqual(new Vector(20, 10), PanelNamed(view, "markdown image a.png").Bounds.Size);
            }

            public void AnImageSitsInTheMiddleOfTheColumn()
            {
                var images = new Dictionary<string, Material> { ["a.png"] = ImageOfSize(20, 10) };
                MarkdownView view = NewView("![alt](a.png)", width: 100, images: images);

                CheckEqual((Scalar)(Padding + (100 - 2 * Padding - 20) / 2),
                    PanelNamed(view, "markdown image a.png").Bounds.Left);
            }

            public void AnImageShrinksToTheWidthKeepingItsProportions()
            {
                var images = new Dictionary<string, Material> { ["a.png"] = ImageOfSize(200, 100) };
                MarkdownView view = NewView("![alt](a.png)", width: 100, images: images);

                CheckEqual(new Vector(100 - 2 * Padding, (100 - 2 * Padding) / 2),
                    PanelNamed(view, "markdown image a.png").Bounds.Size);
            }

            public void ContentIsAsWideAsTheViewAndEndsAtThePadding()
            {
                MarkdownView view = NewView("abcd", width: 100, height: 20);

                CheckEqual(new Vector(100, Padding + 4 + Padding), view.ContentSize);
            }

            public void SettingNarrowerBoundsWrapsTheTextAgain()
            {
                MarkdownView view = NewView("aaaa bbbb", width: 100);
                Label label = LabelWith(view, "aaaa bbbb");

                view.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(24 + 2 * Padding, 60));

                CheckEqual(8, label.Bounds.Height);
            }

            public void SettingWiderBoundsUnwrapsTheTextAgain()
            {
                MarkdownView view = NewView("aaaa bbbb", width: 24 + 2 * Padding);
                Label label = LabelWith(view, "aaaa bbbb");

                view.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(100, 60));

                CheckEqual(4, label.Bounds.Height);
            }

            public void ABoundsTooNarrowForThePaddingLaysNothingOut()
            {
                MarkdownView view = NewView("abcd", width: 2 * Padding);

                CheckEqual(Vector.Zero, view.ContentSize);
            }

            public void ReflowLaysOutAgainWithoutNewBounds()
            {
                MarkdownView view = NewView("abcd");
                Label label = LabelWith(view, "abcd");
                label.Bounds = Rect.Zero;

                view.Reflow();

                CheckEqual(new Vector(Padding, Padding), label.Bounds.TopLeft);
            }
        }

        public class ScrollToHeadingTests : TestFixture
        {
            private static readonly string Document = "# One\n\n" + string.Join("\n\n", Enumerable.Repeat("line", 4))
                + "\n\n# Two\n\n" + string.Join("\n\n", Enumerable.Repeat("line", 6));

            public void ScrollsTheHeadingToTheTopOfTheView()
            {
                MarkdownView view = NewView(Document, height: 30);

                view.ScrollToHeading(1);

                CheckEqual(LabelWith(view, "Two").Bounds.Top - Padding, view.ScrollOffset.Y);
            }

            public void TheFirstHeadingNeedsNoScrolling()
            {
                MarkdownView view = NewView(Document, height: 30);
                view.ScrollToHeading(1);

                view.ScrollToHeading(0);

                CheckEqual((Scalar)0, view.ScrollOffset.Y);
            }

            public void ANegativeIndexThrows()
            {
                MarkdownView view = NewView(Document);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                view.ScrollToHeading(-1);
            }

            public void AnIndexPastTheLastHeadingThrows()
            {
                MarkdownView view = NewView(Document);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                view.ScrollToHeading(2);
            }
        }
    }
}