XmlLayout.cs

using SkiaSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Emoji;
using Waher.Content.Images;
using Waher.Content.Markdown.Contracts;
using Waher.Content.Markdown.Latex;
using Waher.Content.Markdown.Model;
using Waher.Content.Markdown.Model.CodeContent;
using Waher.Content.Markdown.Rendering;
using Waher.Content.Markdown.Wpf;
using Waher.Content.Markdown.Xamarin;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Layout.Layout2D;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Runtime.Timing;
using Waher.Script;
using Waher.Script.Graphs;
using Waher.Security;
 
namespace Waher.Content.Markdown.Layout2D
{
    internal class GraphInfo
    {
        public XmlDocument Xml;
        public string FileName;
        public string Title;
        public bool Dynamic;
        public byte[] DynamicContent;
        public bool Converted;
    }
 
    public class XmlLayout : IImageCodeContent, IXmlVisualizer, ICodeContentMarkdownRenderer, ICodeContentHtmlRenderer, ICodeContentTextRenderer,
        ICodeContentContractsRenderer, ICodeContentLatexRenderer, ICodeContentWpfXamlRenderer, ICodeContentXamarinFormsXamlRenderer
    {
        internal const string DefaultContentType = ImageCodec.ContentTypePng;
        internal const string DefaultFileExtension = ImageCodec.FileExtensionPng;
        internal const SKEncodedImageFormat DefaultFormat = SKEncodedImageFormat.Png;
        internal const int DefaultQuality = 100;
 
        private static readonly Random rnd = new Random();
        private static Scheduler scheduler = null;
        private static string layoutFolder = null;
        private static string contentRootFolder = null;
 
        public XmlLayout()
        {
        }
 
        public static void Init(string ContentRootFolder)
        {
            contentRootFolder = ContentRootFolder;
            layoutFolder = Path.Combine(contentRootFolder, "Layout");
 
            if (scheduler is null)
            {
                if (Types.TryGetModuleParameter("Scheduler", out Scheduler Scheduler))
                    scheduler = Scheduler;
                else
                {
                    scheduler = new Scheduler();
 
                    Log.Terminating += (Sender, e) =>
                    {
                        scheduler?.Dispose();
                        scheduler = null;
                        return Task.CompletedTask;
                    };
                }
            }
 
            if (!Directory.Exists(layoutFolder))
                Directory.CreateDirectory(layoutFolder);
 
            DeleteOldFiles(TimeSpan.FromDays(7));
        }
 
        private static void DeleteOldFiles(object P)
        {
            if (P is TimeSpan MaxAge)
                DeleteOldFiles(MaxAge, true);
        }
 
        public static void DeleteOldFiles(TimeSpan MaxAge, bool Reschedule)
        {
            if (string.IsNullOrEmpty(layoutFolder))
                return;
 
            DateTime Limit = DateTime.Now - MaxAge;
            int Count = 0;
 
            DirectoryInfo LayoutFolder = new DirectoryInfo(layoutFolder);
            FileInfo[] Files = LayoutFolder.GetFiles("*.*");
 
            foreach (FileInfo FileInfo in Files)
            {
                if (FileInfo.LastAccessTime < Limit)
                {
                    try
                    {
                        File.Delete(FileInfo.FullName);
                        Count++;
                    }
                    catch (Exception ex)
                    {
                        Log.Error("Unable to delete old file: " + ex.Message, FileInfo.FullName);
                    }
                }
            }
 
            if (Count > 0)
                Log.Informational(Count.ToString() + " old file(s) deleted.", layoutFolder);
 
            if (Reschedule)
            {
                lock (rnd)
                {
                    scheduler.Add(DateTime.Now.AddDays(rnd.NextDouble() * 2), DeleteOldFiles, MaxAge);
                }
            }
        }
 
        public Grade Supports(string Language)
        {
            int i = Language.IndexOf(':');
            if (i > 0)
                Language = Language.Substring(0, i).TrimEnd();
 
            switch (Language.ToLower())
            {
                case "layout":
                    return Grade.Excellent;
            }
 
            return Grade.NotAtAll;
        }
 
        public bool EvaluatesScript => true;
 
        public void Register(MarkdownDocument Document)
        {
            // Do nothing.
        }
 
        public async Task<bool> RenderHtml(HtmlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return false;
 
            string FileName = Info.FileName.Substring(contentRootFolder.Length).Replace(Path.DirectorySeparatorChar, '/');
            if (!FileName.StartsWith("/"))
                FileName = "/" + FileName;
 
            StringBuilder Output = Renderer.Output;
 
            Output.Append("<figure>");
            Output.Append("<img src=\"");
            if (Info.Dynamic)
                Output.Append(ImageContent.GenerateUrl(Info.DynamicContent, DefaultContentType));
            else
                Output.Append(XML.HtmlAttributeEncode(FileName));
 
            if (!string.IsNullOrEmpty(Info.Title))
            {
                Output.Append("\" alt=\"");
                Output.Append(XML.HtmlAttributeEncode(Info.Title));
 
                Output.Append("\" title=\"");
                Output.Append(XML.HtmlAttributeEncode(Info.Title));
            }
            else
                Output.Append("\" alt=\"2D-layout");
 
            Output.Append("\" class=\"aloneUnsized\"/>");
 
            if (!string.IsNullOrEmpty(Info.Title))
            {
                Output.Append("<figcaption>");
                Output.Append(XML.HtmlValueEncode(Info.Title));
                Output.Append("</figcaption>");
            }
 
            Output.AppendLine("</figure>");
 
            return true;
        }
 
        internal static Task<GraphInfo> GetFileName(string Language, string[] Rows, Variables Session,
            SKEncodedImageFormat ImageFormat, int Quality, string FileExtension)
        {
            return GetFileName(Language, MarkdownDocument.AppendRows(Rows), Session, ImageFormat, Quality, FileExtension);
        }
 
        internal static async Task<GraphInfo> GetFileName(string Language, string Xml, Variables Session,
            SKEncodedImageFormat ImageFormat, int Quality, string FileExtension)
        {
            GraphInfo Result = new GraphInfo();
            int i = Language.IndexOf(':');
 
            if (i > 0)
            {
                Result.Title = Language.Substring(i + 1).Trim();
                Language = Language.Substring(0, i).TrimEnd();
            }
            else
                Result.Title = string.Empty;
 
            string GraphBgColor = GetColor(Graph.GraphBgColorVariableName, Session);
            string GraphFgColor = GetColor(Graph.GraphFgColorVariableName, Session);
 
            string Hash = Hashes.ComputeSHA256HashString(Encoding.UTF8.GetBytes(Xml + Language + GraphBgColor + GraphFgColor));
 
            string LayoutFolder = Path.Combine(contentRootFolder, "Layout");
            string FileName = Path.Combine(LayoutFolder, Hash);
            Result.FileName = FileName + "." + FileExtension;
 
            if (File.Exists(Result.FileName))
                Result.Converted = true;
            else
            {
                Result.Xml = XML.ParseXml(Xml);
 
                if (Layout2DDocument.IsLayoutXml(Result.Xml))
                {
                    Layout2DDocument LayoutDoc = await Layout2DDocument.FromXml(Result.Xml, Session);
                    RenderSettings Settings = await LayoutDoc.GetRenderSettings(Session);
 
                    KeyValuePair<SKImage, Map[]> P = await LayoutDoc.Render(Settings);
                    using (SKImage Img = P.Key)   // TODO: Maps
                    {
                        using (SKData Data = Img.Encode(ImageFormat, Quality))
                        {
                            Result.DynamicContent = Data.ToArray();
                            Result.Dynamic = LayoutDoc.Dynamic;
 
                            if (!LayoutDoc.Dynamic)
                                await Files.WriteAllBytesAsync(Result.FileName, Result.DynamicContent);
                        }
                    }
 
                    Result.Converted = true;
                }
                else
                    Result.Converted = false;
            }
 
            return Result;
        }
 
        private static string GetColor(string VariableName, Variables Variables)
        {
            if (Variables is null)
                return null;
 
            if (!Variables.TryGetVariable(VariableName, out Variable v))
                return null;
 
            if (v.ValueObject is SKColor Color)
                return Graph.ToRGBAStyle(Color);
            else if (v.ValueObject is string s)
                return s;
            else
                return null;
        }
 
        public async Task<bool> RenderMarkdown(MarkdownRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return false;
 
            if (Info.Dynamic)
            {
                ImageContent.GenerateMarkdown(Renderer.Output, Info.DynamicContent, DefaultContentType, Info.Title);
                return true;
            }
            else
                return await ImageContent.GenerateMarkdownFromFile(Renderer.Output, Info.FileName, Info.Title);
        }
 
        public async Task<bool> RenderText(TextRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return false;
 
            Renderer.Output.AppendLine(Info.Title);
 
            return true;
        }
 
        public async Task<bool> RenderWpfXaml(WpfXamlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return false;
 
            XmlWriter Output = Renderer.XmlOutput;
 
            if (Info.Dynamic)
            {
                await Wpf.Multimedia.ImageContent.OutputWpf(Output, new ImageSource()
                {
                    Url = ImageContent.GenerateUrl(Info.DynamicContent, DefaultContentType)
                }, Info.Title);
            }
            else
            {
                Output.WriteStartElement("Image");
                Output.WriteAttributeString("Source", Info.FileName);
                Output.WriteAttributeString("Stretch", "None");
 
                if (!string.IsNullOrEmpty(Info.Title))
                    Output.WriteAttributeString("ToolTip", Info.Title);
 
                Output.WriteEndElement();
            }
 
            return true;
        }
 
        public async Task<bool> RenderXamarinFormsXaml(XamarinFormsXamlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return false;
 
            XmlWriter Output = Renderer.XmlOutput;
 
            if (Info.Dynamic)
            {
                await Xamarin.Multimedia.ImageContent.OutputXamarinForms(Output, new ImageSource()
                {
                    Url = ImageContent.GenerateUrl(Info.DynamicContent, DefaultContentType)
                });
            }
            else
            {
                Output.WriteStartElement("Image");
                Output.WriteAttributeString("Source", Info.FileName);
                Output.WriteEndElement();
            }
 
            return true;
        }
 
        public async Task<bool> RenderLatex(LatexRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return false;
 
            if (Info.Dynamic)
                Info.FileName = await Model.Multimedia.ImageContent.GetTemporaryFile(Info.DynamicContent, DefaultFileExtension.Substring(1));
 
            StringBuilder Output = Renderer.Output;
 
            Output.AppendLine("\\begin{figure}[h]");
            Output.AppendLine("\\centering");
 
            Output.Append("\\fbox{\\includegraphics{");
            Output.Append(Info.FileName.Replace('\\', '/'));
            Output.AppendLine("}}");
 
            if (!string.IsNullOrEmpty(Info.Title))
            {
                Output.Append("\\caption{");
                Output.Append(LatexRenderer.EscapeLaTeX(Info.Title));
                Output.AppendLine("}");
            }
 
            Output.AppendLine("\\end{figure}");
            Output.AppendLine();
 
            return true;
        }
 
        public async Task<PixelInformation> GenerateImage(string[] Rows, string Language, MarkdownDocument Document)
        {
            GraphInfo Info = await GetFileName(Language, Rows, Document.Settings.Variables, DefaultFormat, DefaultQuality, DefaultFileExtension);
            if (Info?.FileName is null || !Info.Converted)
                return null;
 
            byte[] Data = await Files.ReadAllBytesAsync(Info.FileName);
 
            using (SKBitmap Bitmap = SKBitmap.Decode(Data))
            {
                return new PixelInformationPng(Data, Bitmap.Width, Bitmap.Height);
            }
        }
 
        public Grade Supports(XmlDocument Xml)
        {
            return Layout2DDocument.IsLayoutXml(Xml) ? Grade.Excellent : Grade.NotAtAll;
        }
 
        public async Task<object> TransformXml(XmlDocument Xml, Variables Session)
        {
            Layout2DDocument LayoutDoc = await Layout2DDocument.FromXml(Xml, Session);
            RenderSettings Settings = await LayoutDoc.GetRenderSettings(Session);
 
            KeyValuePair<SKImage, Map[]> P = await LayoutDoc.Render(Settings);
            using (SKImage Img = P.Key)   // TODO: Maps
            {
                return PixelInformation.FromImage(Img);
            }
        }
 
        public async Task<bool> RenderContractXml(ContractsRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            string Xml = MarkdownDocument.AppendRows(Rows);
 
            try
            {
                string Title;
                int i = Language.IndexOf(':');
 
                if (i > 0)
                {
                    Title = Language.Substring(i + 1).Trim();
                    Language = Language.Substring(0, i).TrimEnd();
                }
                else
                    Title = string.Empty;
 
                XmlDocument Doc = XML.ParseXml(Xml);
 
                Variables Variables = Document.Settings.Variables;
                Layout2DDocument LayoutDoc = await Layout2DDocument.FromXml(Doc, Variables);
                RenderSettings Settings = await LayoutDoc.GetRenderSettings(Variables);
                XmlWriter Output = Renderer.XmlOutput;
 
                KeyValuePair<SKImage, Map[]> P = await LayoutDoc.Render(Settings);
 
                using (SKImage Img = P.Key)
                {
                    Output.WriteStartElement("imageStandalone");
 
                    Output.WriteAttributeString("contentType", DefaultContentType);
                    Output.WriteAttributeString("width", Img.Width.ToString());
                    Output.WriteAttributeString("height", Img.Height.ToString());
 
                    using (SKData Data = Img.Encode(DefaultFormat, DefaultQuality))
                    {
                        byte[] Bin = Data.ToArray();
 
                        Output.WriteStartElement("binary");
                        Output.WriteValue(Convert.ToBase64String(Bin));
                        Output.WriteEndElement();
                    }
 
                    Output.WriteStartElement("caption");
                    if (string.IsNullOrEmpty(Title))
                        Output.WriteElementString("text", "Layout");
                    else
                        Output.WriteElementString("text", Title);
 
                    Output.WriteEndElement();
                    Output.WriteEndElement();
                }
 
                return true;
            }
            catch (XmlException ex)
            {
                ex = XML.AnnotateException(ex, Xml);
                Log.Exception(ex);
                return false;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
 
    }
}