PlantUml.cs

using SkiaSharp;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
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.SystemFiles;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Runtime.Collections;
using Waher.Runtime.Inventory;
using Waher.Runtime.IO;
using Waher.Runtime.Queue;
using Waher.Runtime.Timing;
using Waher.Script;
using Waher.Script.Graphs;
using Waher.Security;
using static System.Environment;
 
namespace Waher.Content.Markdown.PlantUml
{
    internal enum ResultType
    {
        Svg,
        Png
    }
 
    internal class GraphInfo
    {
        public string BaseFileName;
        public string TxtFileName;
        public string ImageFileName;
        public bool ImageExists;
        public string PlantUmlFolder;
        public string Title;
        public string AsyncId;
        public bool Sent;
    }
 
    public class PlantUml : IImageCodeContent, ICodeContentHtmlRenderer, ICodeContentTextRenderer, ICodeContentMarkdownRenderer,
        ICodeContentContractsRenderer, ICodeContentLatexRenderer, ICodeContentWpfXamlRenderer, ICodeContentXamarinFormsXamlRenderer
    {
        private const int chartGenerationTimeout = 30000;
 
        private static readonly AsyncProcessor<ChartRecord> queue = new AsyncProcessor<ChartRecord>(1, "PlantUML processor");
        private static readonly Random rnd = new Random();
        private static Scheduler scheduler = null;
        private static string jarPath = null;
        private static string javaPath = null;
        private static string plantUmlFolder = null;
        private static string contentRootFolder = null;
        private static IMarkdownAsynchronousOutput asyncHtmlOutput = null;
 
        public PlantUml()
        {
        }
 
        public static void Init(string ContentRootFolder)
        {
            try
            {
                contentRootFolder = ContentRootFolder;
 
                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;
                        };
                    }
                }
 
                SearchForInstallationFolder(out string JarPath, out string JavaPath);
 
                if (string.IsNullOrEmpty(JarPath))
                    Log.Warning("PlantUML not found. PlantUML support will not be available in Markdown.");
                else if (string.IsNullOrEmpty(JavaPath))
                    Log.Warning("Java not found. PlantUML support will not be available in Markdown.");
                else
                {
                    SetPath(JarPath, JavaPath);
 
                    Log.Informational("PlantUML found. Integration with Markdown added.",
                        new KeyValuePair<string, object>("Path", jarPath),
                        new KeyValuePair<string, object>("Java", javaPath));
 
 
                    asyncHtmlOutput = Types.FindBest<IMarkdownAsynchronousOutput, MarkdownOutputType>(MarkdownOutputType.Html);
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public static async Task Terminate()
        {
            try
            {
                await queue.CloseForTermination(true, chartGenerationTimeout);
                await queue.DisposeAsync();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public static void SetPath(string JarPath, string JavaPath)
        {
            if (!string.IsNullOrEmpty(jarPath) && JarPath != jarPath)
                throw new Exception("PlantUML an Java paths have already been set.");
 
            jarPath = JarPath;
            javaPath = JavaPath;
            plantUmlFolder = Path.Combine(contentRootFolder, "PlantUML");
 
            if (!Directory.Exists(plantUmlFolder))
                Directory.CreateDirectory(plantUmlFolder);
 
            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(plantUmlFolder))
                return;
 
            DateTime Limit = DateTime.Now - MaxAge;
            int Count = 0;
 
            DirectoryInfo PlantUmlFolder = new DirectoryInfo(plantUmlFolder);
            FileInfo[] Files = PlantUmlFolder.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.", plantUmlFolder);
 
            if (Reschedule)
            {
                lock (rnd)
                {
                    scheduler.Add(DateTime.Now.AddDays(rnd.NextDouble() * 2), DeleteOldFiles, MaxAge);
                }
            }
        }
 
        public static void SearchForInstallationFolder(out string JarPath, out string JavaPath)
        {
            ChunkedList<string> Folders = new ChunkedList<string>();
 
            Folders.AddRange(FileSystem.GetFolders(new Environment.SpecialFolder[]
            {
                SpecialFolder.ProgramFiles,
                SpecialFolder.ProgramFilesX86
            }));
 
            if (Types.TryGetModuleParameter("Runtime", out string RuntimeFolder))
            {
                Folders.Add(Path.Combine(RuntimeFolder, SpecialFolder.ProgramFiles.ToString()));
                Folders.Add(Path.Combine(RuntimeFolder, SpecialFolder.ProgramFilesX86.ToString()));
            }
 
            string PathVar = Environment.GetEnvironmentVariable("PATH");
            if (!string.IsNullOrEmpty(PathVar))
            {
                string[] Paths = PathVar.Split(Path.PathSeparator);
                Folders.AddRange(Paths);
            }
 
            string[] Folders2 = Folders.ToArray();
 
            JarPath = FileSystem.FindLatestFile(Folders2, "plantuml.jar", 1);
            JavaPath = FileSystem.FindLatestFile(Folders2, "java" + FileSystem.ExecutableExtension, 3);
        }
 
        public Grade Supports(string Language)
        {
            if (!string.IsNullOrEmpty(jarPath) && !string.IsNullOrEmpty(javaPath))
            {
                int i = Language.IndexOf(':');
                if (i > 0)
                    Language = Language.Substring(0, i).TrimEnd();
 
                switch (Language.ToLower())
                {
                    case "uml": return Grade.Excellent;
                    case "plantuml": return Grade.Perfect;
                }
            }
 
            return Grade.NotAtAll;
        }
 
        public bool EvaluatesScript => false;
 
        public void Register(MarkdownDocument Document)
        {
            // Do nothing.
        }
 
        public async Task<bool> RenderHtml(HtmlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            StringBuilder Output = Renderer.Output;
            bool GenerateIfNotExists = asyncHtmlOutput is null;
            GraphInfo Info = await GetGraphInfo(Language, Rows, ResultType.Svg, GenerateIfNotExists);
            
            if (GenerateIfNotExists || Info.ImageExists)
            {
                this.GenerateHTML(Output, Info);
                return true;
            }
 
            Info.AsyncId = await asyncHtmlOutput.GenerateStub(MarkdownOutputType.Html, Output, Info.Title, Document);
 
            foreach (KeyValuePair<AsyncMarkdownProcessing, object> P in Document.AsyncTasks)
            {
                if (P.Value is AsyncState AsyncState && AsyncState.Type == ResultType.Svg && AsyncState.GraphInfos.Count < 10)
                {
                    AsyncState.GraphInfos.Add(Info);
                    return true;
                }
            }
 
            Document.QueueAsyncTask(this.ExecutePlantUml, new AsyncState(ResultType.Svg, Info));
 
            return true;
        }
 
        private class AsyncState
        {
            public readonly ChunkedList<GraphInfo> GraphInfos;
            public readonly ResultType Type;
 
            public AsyncState(ResultType Type, GraphInfo Info)
            {
                this.Type = Type;
                this.GraphInfos = new ChunkedList<GraphInfo>()
                {
                    Info
                };
            }
        }
 
        private async Task ExecutePlantUml(object State)
        {
            using (HtmlRenderer Renderer = new HtmlRenderer(new HtmlSettings()
            {
                XmlEntitiesOnly = true
            }))
            {
                AsyncState AsyncState = (AsyncState)State;
 
                try
                {
                    await ExecutePlantUml(AsyncState.Type, AsyncState.GraphInfos.ToArray());
 
                    foreach (GraphInfo Info in AsyncState.GraphInfos)
                    {
                        Renderer.Clear();
 
                        this.GenerateHTML(Renderer.Output, Info);
                        await asyncHtmlOutput.ReportResult(MarkdownOutputType.Html, Info.AsyncId, Renderer.ToString());
                        Info.Sent = true;
                    }
                }
                catch (Exception ex)
                {
                    Renderer.Clear();
                    await Renderer.RenderObject(ex, true, new Variables());
 
                    string s = Renderer.ToString();
 
                    foreach (GraphInfo Info in AsyncState.GraphInfos)
                    {
                        if (!Info.Sent)
                            await asyncHtmlOutput.ReportResult(MarkdownOutputType.Html, Info.AsyncId, s);
                    }
                }
            }
        }
 
        private static async Task ExecutePlantUml(ResultType Type, params GraphInfo[] Files)
        {
            ChartRecord Rec = new ChartRecord(Type, Files);
            queue.Queue(Rec);
 
            if (!await Rec.Wait())
                throw new Exception("Unable to process PlantUML chart.");
        }
 
        private class ChartRecord : IWorkItem
        {
            private readonly TaskCompletionSource<bool> result = new TaskCompletionSource<bool>();
            private readonly ResultType type;
            private readonly GraphInfo[] files;
 
            public ChartRecord(ResultType Type, params GraphInfo[] Files)
            {
                this.type = Type;
                this.files = Files;
            }
 
            public Task Execute()
            {
                return this.Execute(CancellationToken.None);
            }
 
            public async Task Execute(CancellationToken Cancel)
            {
                StringBuilder Arguments = new StringBuilder();
                Arguments.Append("-jar \"");
                Arguments.Append(jarPath);
                Arguments.Append("\" -quiet -charset UTF-8 -t");
                Arguments.Append(this.type.ToString().ToLower());
 
                foreach (GraphInfo Info in this.files)
                {
                    Arguments.Append(" \"");
                    Arguments.Append(Info.TxtFileName);
                    Arguments.Append('"');
                }
 
                ProcessStartInfo ProcessInformation = new ProcessStartInfo()
                {
                    FileName = javaPath,
                    Arguments = Arguments.ToString(),
                    UseShellExecute = false,
                    RedirectStandardError = true,
                    RedirectStandardOutput = true,
                    RedirectStandardInput = false,
                    WorkingDirectory = this.files[0].PlantUmlFolder,
                    CreateNoWindow = true,
                    WindowStyle = ProcessWindowStyle.Hidden
                };
 
                Process P = new Process();
                TaskCompletionSource<int> ExitSource = new TaskCompletionSource<int>();
 
                P.Exited += (Sender, e) =>
                {
                    ExitSource.TrySetResult(P.ExitCode);
                };
 
                Task _ = Task.Delay(chartGenerationTimeout).ContinueWith(Prev =>
                {
                    try
                    {
                        P.Kill();
 
                        foreach (GraphInfo Info in this.files)
                        {
                            if (File.Exists(Info.ImageFileName))
                                File.Delete(Info.ImageFileName);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                    finally
                    {
                        ExitSource.TrySetException(new TimeoutException("PlantUML process did not terminate properly."));
                    }
 
                    return Task.CompletedTask;
                });
 
                P.StartInfo = ProcessInformation;
                P.EnableRaisingEvents = true;
                P.Start();
 
                int ExitCode = await ExitSource.Task;
 
                if (ExitCode != 0)
                {
                    string Error = P.StandardError.ReadToEnd();
                    this.result.TrySetException(new Exception(Error));
                }
            }
 
            public void Processed(bool Result)
            {
                this.result.TrySetResult(Result);
            }
 
            public Task<bool> Wait()
            {
                return this.result.Task;
            }
 
            public Task<bool> Wait(CancellationToken Cancel)
            {
                if (Cancel.CanBeCanceled)
                    Cancel.Register(() => this.result.TrySetException(new OperationCanceledException(Cancel)));
                    
                return this.result.Task;
            }
        }
 
        private void GenerateHTML(StringBuilder Output, GraphInfo Info)
        {
            Info.ImageFileName = Info.ImageFileName.Substring(contentRootFolder.Length).Replace(Path.DirectorySeparatorChar, '/');
            if (!Info.ImageFileName.StartsWith("/"))
                Info.ImageFileName = "/" + Info.ImageFileName;
 
            Output.Append("<figure>");
            Output.Append("<img src=\"");
            Output.Append(XML.HtmlAttributeEncode(Info.ImageFileName));
 
            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=\"PlantUML graph");
 
            Output.Append("\" class=\"aloneUnsized\"/>");
 
            if (!string.IsNullOrEmpty(Info.Title))
            {
                Output.Append("<figcaption>");
                Output.Append(XML.HtmlValueEncode(Info.Title));
                Output.Append("</figcaption>");
            }
 
            Output.AppendLine("</figure>");
        }
 
        internal static Task<GraphInfo> GetGraphInfo(string Language, string[] Rows, ResultType Type)
        {
            return GetGraphInfo(Language, MarkdownDocument.AppendRows(Rows), Type);
        }
 
        internal static async Task<GraphInfo> GetGraphInfo(string Language, string Graph, ResultType Type)
        {
            string FileName = Hashes.ComputeSHA256HashString(Encoding.UTF8.GetBytes(Graph + Language));
            string PlantUmlFolder = Path.Combine(contentRootFolder, "PlantUML");
 
            GraphInfo Result = new GraphInfo()
            {
                BaseFileName = Path.Combine(PlantUmlFolder, FileName),
                PlantUmlFolder = PlantUmlFolder
            };
            int i = Language.IndexOf(':');
 
            if (i > 0)
                Result.Title = Language.Substring(i + 1).Trim();
            else
                Result.Title = string.Empty;
 
            Result.TxtFileName = Result.BaseFileName + ".txt";
            if (!File.Exists(Result.TxtFileName))
                await Files.WriteAllTextAsync(Result.TxtFileName, Graph, Encoding.UTF8);
 
            switch (Type)
            {
                case ResultType.Svg:
                default:
                    Result.ImageFileName = Result.BaseFileName + "." + ImageCodec.FileExtensionSvg;
                    break;
 
                case ResultType.Png:
                    Result.ImageFileName = Result.BaseFileName + "." + ImageCodec.FileExtensionPng;
                    break;
            }
 
            Result.ImageExists = File.Exists(Result.ImageFileName);
            if (Result.ImageExists)
            {
                FileInfo Info = new FileInfo(Result.ImageFileName);
                if (Info.Length == 0)
                    Result.ImageExists = false;
            }
 
            return Result;
        }
 
        internal static Task<GraphInfo> GetGraphInfo(string Language, string[] Rows, ResultType Type, bool GenerateIfNotExists)
        {
            return GetGraphInfo(Language, MarkdownDocument.AppendRows(Rows), Type, GenerateIfNotExists);
        }
 
        internal static async Task<GraphInfo> GetGraphInfo(string Language, string GraphDefinition, ResultType Type, bool GenerateIfNotExists)
        {
            GraphInfo Result = await GetGraphInfo(Language, GraphDefinition, Type);
 
            if (GenerateIfNotExists && !Result.ImageExists)
                await ExecutePlantUml(Type, Result);
 
            return Result;
        }
 
        public async Task<bool> RenderMarkdown(MarkdownRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetGraphInfo(Language, Rows, ResultType.Png, true);
            if (Info is null)
                return false;
 
            return await ImageContent.GenerateMarkdownFromFile(Renderer.Output, Info.ImageFileName, Info.Title);
        }
 
 
        public async Task<bool> RenderText(TextRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetGraphInfo(Language, Rows, ResultType.Svg, true);
            if (Info is null)
                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 GetGraphInfo(Language, Rows, ResultType.Png, true);
            if (Info is null)
                return false;
 
            XmlWriter Output = Renderer.XmlOutput;
 
            Output.WriteStartElement("Image");
            Output.WriteAttributeString("Source", Info.ImageFileName);
            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 GetGraphInfo(Language, Rows, ResultType.Png, true);
            if (Info is null)
                return false;
 
            XmlWriter Output = Renderer.XmlOutput;
 
            Output.WriteStartElement("Image");
            Output.WriteAttributeString("Source", Info.ImageFileName);
            Output.WriteEndElement();
 
            return true;
        }
 
        public async Task<bool> RenderLatex(LatexRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            GraphInfo Info = await GetGraphInfo(Language, Rows, ResultType.Png, true);
            StringBuilder Output = Renderer.Output;
 
            Output.AppendLine("\\begin{figure}[h]");
            Output.AppendLine("\\centering");
 
            Output.Append("\\fbox{\\includegraphics{");
            Output.Append(Info.ImageFileName.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 GetGraphInfo(Language, Rows, ResultType.Png, true);
            if (Info is null)
                return null;
 
            byte[] Data = await Runtime.IO.Files.ReadAllBytesAsync(Info.ImageFileName);
 
            using (SKBitmap Bitmap = SKBitmap.Decode(Data))
            {
                return new PixelInformationPng(Data, Bitmap.Width, Bitmap.Height);
            }
        }
 
        public async Task<bool> RenderContractXml(ContractsRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            try
            {
                GraphInfo Info = await GetGraphInfo(Language, Rows, ResultType.Png, true);
                if (Info is null)
                    return false;
 
                byte[] Data = await Runtime.IO.Files.ReadAllBytesAsync(Info.ImageFileName);
                string ContentType = ImageCodec.ContentTypePng;
                ContentResponse Content = await InternetContent.DecodeAsync(ContentType, Data, null);
 
                if (Content.HasError || !(Content.Decoded is SKImage Image))
                    return false;
 
                XmlWriter Output = Renderer.XmlOutput;
                int Width = Image.Width;
                int Height = Image.Height;
 
                Output.WriteStartElement("imageStandalone");
 
                Output.WriteAttributeString("contentType", ContentType);
                Output.WriteAttributeString("width", Width.ToString());
                Output.WriteAttributeString("height", Height.ToString());
 
                Output.WriteStartElement("binary");
                Output.WriteValue(Convert.ToBase64String(Data));
                Output.WriteEndElement();
 
                Output.WriteStartElement("caption");
                if (string.IsNullOrEmpty(Info.Title))
                    Output.WriteElementString("text", "Graph");
                else
                    Output.WriteElementString("text", Info.Title);
 
                Output.WriteEndElement();
                Output.WriteEndElement();
 
                return true;
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return false;
            }
        }
    }
}