QuestPDF/Source/QuestPDF.LayoutTests/TestEngine/LayoutTestOutputVisualization.cs

using QuestPDF.Drawing;
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;
using SkiaSharp;

namespace QuestPDF.LayoutTests.TestEngine;

internal static class LayoutTestResultVisualization
{
    // visual settings
    private const string DocumentBackgroundColor = Colors.Grey.Lighten1;
    private const string PageBackgroundColor = Colors.Grey.Lighten3;
    private const string RequiredAreaBackgroundColor = Colors.White;
    private const string GridLineColor = Colors.Grey.Lighten1;

    private static readonly string[] DefaultElementColors =
    {
        Colors.Green.Darken2,
        Colors.Blue.Darken2,
        Colors.Orange.Darken2,
        Colors.Lime.Darken2,
        Colors.Cyan.Darken2,
        Colors.Indigo.Darken2,
        
        Colors.Green.Lighten1,
        Colors.Blue.Lighten1,
        Colors.Orange.Lighten1,
        Colors.Lime.Lighten1,
        Colors.Cyan.Lighten1,
        Colors.Indigo.Lighten1
    };

    private const int Padding = 32;
    private const int OutputImageScale = 2;

    private const float GridSize = 10;
    
    private const float MockBorderThickness = 2;
    private const byte MockBackgroundOpacity = 128;
    
    // implementations
    public static void Visualize(LayoutTestResult result, Stream stream)
    {
        // determine output dimenstions
        var numberOfPages = Math.Max(result.ActualLayout.Pages.Count, result.ExpectedLayout.Pages.Count);

        var canvasWidth = result.PageSize.Width * 2 + Padding * 4;
        var canvasHeight = result.PageSize.Height * numberOfPages + Padding * (numberOfPages + 2);

        // create PDF
        using var pdf = SKDocument.CreatePdf(stream);
        using var canvas = pdf.BeginPage(canvasWidth * OutputImageScale, canvasHeight * OutputImageScale);
        
        canvas.Scale(OutputImageScale, OutputImageScale);
        canvas.Clear(SKColor.Parse(DocumentBackgroundColor));

        // draw content
        var mockColors = AssignColorsToMocks();
        DrawDocument();

        // finish generation
        pdf.EndPage();
        pdf.Close();

        IDictionary<string, string> AssignColorsToMocks()
        {
            var mocks = Enumerable
                .Concat(result.ActualLayout.Pages, result.ExpectedLayout.Pages)
                .SelectMany(x => x.Mocks)
                .Select(x => x.MockId)
                .Distinct()
                .ToList();

            return Enumerable
                .Range(0, mocks.Count)
                .ToDictionary(i => mocks[i], i => DefaultElementColors[i]);
        }

        void DrawDocument()
        {
            canvas.Translate(Padding, Padding);
            
            // draw title
            using var textPaint = TextStyle.LibraryDefault.FontSize(16).Bold().ToPaint().Clone();
            textPaint.TextAlign = SKTextAlign.Center;

            var actualHeaderPosition = new SKPoint(result.PageSize.Width / 2, textPaint.TextSize / 2);
            canvas.DrawText("ACTUAL", actualHeaderPosition, textPaint);
            
            var expectedHeaderPosition = new SKPoint(Padding * 2 + result.PageSize.Width * 1.5f, textPaint.TextSize / 2);
            canvas.DrawText("EXPECTED", expectedHeaderPosition, textPaint);
            
            // draw pages
            canvas.Save();
            canvas.Translate(0, Padding);
            
            foreach (var pageIndex in Enumerable.Range(0, numberOfPages))
            {
                var actualPage = result.ActualLayout.Pages.ElementAtOrDefault(pageIndex);
                var expectedPage = result.ExpectedLayout.Pages.ElementAtOrDefault(pageIndex);
                
                DrawPage(actualPage);
                DrawLayoutDifferences(actualPage, expectedPage);
                
                canvas.Translate(result.PageSize.Width + Padding, 0);
                canvas.DrawText((pageIndex + 1).ToString(), 0, textPaint.TextSize, textPaint);
                
                canvas.Translate(Padding, 0);
                DrawPage(expectedPage);
                DrawLayoutDifferences(expectedPage, actualPage);
                
                canvas.Translate(-result.PageSize.Width - Padding * 2, result.PageSize.Height + Padding);
            }

            canvas.Restore();
        }
        
        void DrawPage(LayoutTestResult.PageLayout? pageLayout)
        {
            // draw page
            using var availableAreaPaint = new SKPaint
            {
                Color = SKColor.Parse(PageBackgroundColor)
            };
            
            using var requiredAreaPaint = new SKPaint
            {
                Color = SKColor.Parse(RequiredAreaBackgroundColor)
            };
            
            canvas.DrawRect(0, 0, result.PageSize.Width, result.PageSize.Height, availableAreaPaint);
            canvas.DrawRect(0, 0, pageLayout?.RequiredArea.Width ?? 0, pageLayout?.RequiredArea.Height ?? 0, requiredAreaPaint);
            
            DrawGridLines();
            
            if (pageLayout == null)
                return;
            
            // draw mocks
            foreach (var mock in pageLayout.Mocks)
            {
                canvas.Save();

                var color = mockColors[mock.MockId];
            
                using var mockBorderPaint = new SKPaint
                {
                    Color = SKColor.Parse(color),
                    IsStroke = true,
                    StrokeWidth = MockBorderThickness
                };
            
                using var mockAreaPaint = new SKPaint
                {
                    Color = SKColor.Parse(color).WithAlpha(MockBackgroundOpacity)
                };
            
                canvas.Translate(mock.Position.X, mock.Position.Y);
                canvas.DrawRect(0, 0, mock.Size.Width, mock.Size.Height, mockAreaPaint);
                canvas.DrawRect(MockBorderThickness / 2, MockBorderThickness / 2, mock.Size.Width - MockBorderThickness, mock.Size.Height - MockBorderThickness, mockBorderPaint);
            
                canvas.Restore();
            }
        }
        
        void DrawGridLines()
        {
            using var paint = new SKPaint
            {
                Color = SKColor.Parse(GridLineColor),
                StrokeWidth = 1
            };

            var verticalLineCount = (int)Math.Floor(result.PageSize.Width / GridSize);
            var horizontalLineCount = (int)Math.Floor(result.PageSize.Height / GridSize);
            
            foreach (var i in Enumerable.Range(1, verticalLineCount))
                canvas.DrawLine(new SKPoint(i * GridSize, 0), new SKPoint(i * GridSize, result.PageSize.Height), paint);
            
            foreach (var i in Enumerable.Range(1, horizontalLineCount))
                canvas.DrawLine(new SKPoint(0, i * GridSize), new SKPoint(result.PageSize.Width, i * GridSize), paint);
        }

        void DrawLayoutDifferences(LayoutTestResult.PageLayout? target, LayoutTestResult.PageLayout? compareWith)
        {
            using var targetPath = BuildPathFromLayout(target);
            using var compareWithPath = BuildPathFromLayout(compareWith);

            using var differencePath = targetPath.Op(compareWithPath, SKPathOp.Difference);
            
            AnnotateInvalidAreaHelper.Annotate(canvas, differencePath);
            
            SKPath BuildPathFromLayout(LayoutTestResult.PageLayout? layout)
            {
                var resultPath = new SKPath();

                if (layout == null)
                    return resultPath;
                
                foreach (var mock in layout.Mocks)
                {
                    var position = new SKRect(
                        mock.Position.X, 
                        mock.Position.Y, 
                        mock.Position.X + mock.Size.Width, 
                        mock.Position.Y + mock.Size.Height);
                    
                    resultPath.AddRect(position);
                }

                return resultPath;
            }
        }
    }
}