using Annulus;
using Azimuth;
using Clave;
using Glass.Markdown;
using System.Collections.Generic;
using Prism;

namespace Glass.Testbed.TestCases.Text
{
    /// <summary>
    /// One Markdown document in two views of different widths, so the wrapping is easy to compare.  The buttons under
    /// each view scroll it to a heading.
    /// </summary>
    public class MarkdownTestCase : TestCase
    {
        private const string Document = """
            # Reading the grid

            Everything in this document is Markdown, parsed into blocks and laid out down the width of the view.
            Resize a view and the paragraphs wrap again.  Inline marks such as **bold** and `code` are shown as
            written until text can be styled in runs.

            ## Callouts

            1. Play/Pause button - toggles the game between running and paused.
            2. Step button - runs the game forward one tick.
            12. Numbers are kept as written, so a callout can match a number drawn on a screenshot.

            ---

            ## Lists and pictures

            - A bulleted item with enough text to wrap onto a second line when the view is narrow.
            - Another item.

            ![A resize cursor](cursor.png)

            ## Code

            ```
            if (islanded)
            {
                Synchronize(generator, grid);
            }
            ```

            ## The end

            That is all of it.  Scroll up with the wheel, or jump to a heading from the list.
            """;

        private static TextMaterialStyle Styled(SpriteFontDefinition font)
        {
            return new TextMaterialStyle { Font = font, TintColor = Colors.Black };
        }

        private static MarkdownStyle NewStyle()
        {
            return new MarkdownStyle
            {
                Body = Styled(Fonts.LiberationSans16),
                Headings = new[] { Styled(Fonts.LiberationSansBold32), Styled(Fonts.LiberationSansBold16) },
                Code = Styled(Fonts.LiberationMono16),
                CodeBackground = new SolidColorMaterial { Color = Color.FromArgb(40, 0, 0, 0) },
                Rule = new SolidColorMaterial { Color = Color.FromArgb(160, 0, 0, 0) },
                BlockSpacing = 6,
                Padding = 8,
            };
        }

        private MarkdownView NewView(Scalar width, Scalar height)
        {
            var images = new Dictionary<string, Material>
            {
                ["cursor.png"] = ResizeCursorMaterials.DiagonalNwSe with { LockAspectRatio = true },
            };

            var view = new MarkdownView(Document, NewStyle(), images);
            view.ScrollViewMaterial = new ScrollViewMaterial
            {
                Background = Material.Invisible,
                Canvas = UiPacksheetMaterials.GreenFlatPanel,
                HorizontalScrollBar = UiPacksheetMaterials.HorizontalScrollBar,
                VerticalScrollBar = UiPacksheetMaterials.VerticalScrollBar,
            };

            view.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(width, height));
            return view;
        }

        private Button HeadingButton(MarkdownView view, int index)
        {
            Button returnMe = new Label(Widgets.ButtonLabelStyle, view.Headings[index].Text, Constraints.Unbounded)
                .WrapIn(UiPacksheetMaterials.YellowButton, ButtonBehavior.Default);

            returnMe.OnActivate += (ButtonBase _, in KeyboardSnapshot __, KeyboardManager ___) =>
                view.ScrollToHeading(index);

            return returnMe;
        }

        private List<Button> HeadingButtons(MarkdownView view)
        {
            var returnMe = new List<Button>();
            for (int i = 0; i < view.Headings.Count; ++i)
            {
                returnMe.Add(HeadingButton(view, i));
            }

            return returnMe;
        }

        // The margin goes after every row, so the last row needs it too.
        private static Scalar ColumnHeight(MarkdownView view, List<Button> buttons)
        {
            Scalar returnMe = view.Bounds.Height + CaptionMargin;
            foreach (Button button in buttons)
            {
                returnMe += button.Bounds.Height + CaptionMargin;
            }

            return returnMe;
        }

        private void AddViewColumn(Rect column, MarkdownView view, List<Button> buttons)
        {
            Rect remaining = column;
            Rect viewRect = remaining.NewRow(view.Bounds.Height, margin: CaptionMargin);
            view.Bounds = view.Bounds.WithPosition(viewRect.TopLeft);
            Add(view);

            foreach (Button button in buttons)
            {
                Rect slot = remaining.NewRow(button.Bounds.Height, margin: CaptionMargin);
                button.Bounds = Rect.FromPositionAndSize(slot.TopLeft, button.Bounds.Size);
                Add(button);
            }
        }

        protected override void Populate()
        {
            AddCaption("The same document at two widths.  Each button scrolls its view to a heading");

            MarkdownView narrow = NewView(width: 240, height: 360);
            MarkdownView wide = NewView(width: 440, height: 360);

            List<Button> narrowButtons = HeadingButtons(narrow);
            List<Button> wideButtons = HeadingButtons(wide);

            // The views, then a button for each heading beneath them.
            Rect row = ContentAggregator.NewRow(
                Scalar.Max(ColumnHeight(narrow, narrowButtons), ColumnHeight(wide, wideButtons)));
            Rect narrowColumn = row.NewCol(narrow.Bounds.Width, margin: Gutter);
            Rect wideColumn = row.NewCol(wide.Bounds.Width, margin: Gutter);

            AddViewColumn(narrowColumn, narrow, narrowButtons);
            AddViewColumn(wideColumn, wide, wideButtons);
        }
    }
}