AsyncScript.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Markdown;
using Waher.Content.Markdown.Contracts;
using Waher.Content.Markdown.Latex;
using Waher.Content.Markdown.Model;
using Waher.Content.Markdown.Rendering;
using Waher.Content.Markdown.Wpf;
using Waher.Content.Markdown.Xamarin;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Runtime.Inventory;
using Waher.Script;
 
namespace Waher.IoTGateway.CodeContent
{
    public class AsyncScript : ICodeContent, ICodeContentHtmlRenderer, ICodeContentTextRenderer, ICodeContentMarkdownRenderer,
        ICodeContentContractsRenderer, ICodeContentLatexRenderer, ICodeContentWpfXamlRenderer, ICodeContentXamarinFormsXamlRenderer
    {
        private static readonly AsyncMarkdownHtmlContent asyncHtmlOutput = new AsyncMarkdownHtmlContent();
 
        private MarkdownDocument document;
 
        public AsyncScript()
        {
        }
 
        public Grade Supports(string Language)
        {
            int i = Language.IndexOf(':');
            if (i > 0)
                Language = Language[..i].TrimEnd();
 
            if (string.Compare(Language, "async", true) == 0)
                return Grade.Excellent;
            else
                return Grade.NotAtAll;
        }
 
        public bool EvaluatesScript => true;
 
        public void Register(MarkdownDocument Document)
        {
            this.document = Document;
 
            if (!Document.TryGetMetaData("JAVASCRIPT", out KeyValuePair<string, bool>[] Values) ||
                !Contains(Values, "/Events.js"))
            {
                Document.AddMetaData("JAVASCRIPT", "/Events.js");
            }
        }
 
        private static bool Contains(KeyValuePair<string, bool>[] Values, string Value)
        {
            foreach (KeyValuePair<string, bool> P in Values)
            {
                if (string.Compare(P.Key, Value, true) == 0)
                    return true;
            }
 
            return false;
        }
 
        public async Task<bool> RenderHtml(HtmlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            string Title;
            int i = Language.IndexOf(':');
            if (i > 0)
                Title = Language[(i + 1)..].Trim();
            else
                Title = null;
 
            SessionVariables SessionVariables = HttpServer.CreateSessionVariables();
            AsyncState State = new AsyncState()
            {
                Id = await asyncHtmlOutput.GenerateStub(MarkdownOutputType.Html, Renderer.Output, Title, Document),
                Script = this.BuildExpression(Rows),
                Variables = SessionVariables,
                ImplicitPrint = new StringBuilder()
            };
 
            State.Variables.ConsoleOut = new StringWriter(State.ImplicitPrint);
            Document.Settings.Variables?.CopyTo(State.Variables);
 
            if (Document.Settings.Variables is SessionVariables CurrentSessionVariables)
            {
                SessionVariables.LastPost = CurrentSessionVariables.LastPost;
                SessionVariables.CurrentRequest = CurrentSessionVariables.CurrentRequest;
                SessionVariables.CurrentResponse = CurrentSessionVariables.CurrentResponse;
                SessionVariables.CurrentPageVariables = CurrentSessionVariables.CurrentPageVariables;
                SessionVariables.CurrentPageUrl = CurrentSessionVariables.CurrentPageUrl;
            }
 
            Document.QueueAsyncTask(this.ExecuteScript, State);
 
            return true;
        }
 
        private class AsyncState
        {
            public string Id;
            public Expression Script;
            public Variables Variables;
            public StringBuilder ImplicitPrint;
        }
 
        private Task ExecuteScript(object State)
        {
            AsyncState AsyncState = (AsyncState)State;
            return this.Evaluate(AsyncState.Script, AsyncState.Variables, AsyncState.ImplicitPrint, AsyncState.Id);
        }
 
        private Expression BuildExpression(string[] Rows)
        {
            return new Expression(MarkdownDocument.AppendRows(Rows), this.document?.FileName);
        }
 
        private async Task<object> Evaluate(Expression Script, Variables Variables)
        {
            try
            {
                return await Script.EvaluateAsync(Variables);
            }
            catch (Exception ex)
            {
                return Log.UnnestException(ex);
            }
        }
 
        private async Task Evaluate(Expression Script, Variables Variables, StringBuilder ImplicitPrint, string Id)
        {
            async Task Preview(object Sender, PreviewEventArgs e)
            {
                try
                {
                    using HtmlRenderer Renderer2 = new HtmlRenderer(new HtmlSettings()
                    {
                        XmlEntitiesOnly = true
                    });
 
                    await Renderer2.RenderObject(e.Preview.AssociatedObjectValue, true, Variables);
                    await asyncHtmlOutput.ReportResult(MarkdownOutputType.Html, Id, Renderer2.ToString(), true);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            };
 
            using HtmlRenderer Renderer = new HtmlRenderer(new HtmlSettings()
            {
                XmlEntitiesOnly = true
            });
 
            Variables.OnPreview += Preview;
            try
            {
                object Result = await this.Evaluate(Script, Variables);
 
                string Printed = ImplicitPrint.ToString();
                if (!string.IsNullOrEmpty(Printed))
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine("BodyOnly: 1");
 
                    if (this.document?.Settings.AllowScriptTag ?? false)
                        sb.AppendLine("AllowScriptTag: 1");
 
                    sb.AppendLine();
                    sb.Append(Printed);
 
                    MarkdownDocument Doc;
 
                    if (!(this.document is null))
                        Doc = await MarkdownDocument.CreateAsync(sb.ToString(), this.document.Settings);
                    else if (Variables.TryGetVariable(MarkdownDocument.MarkdownSettingsVariableName, out Variable v) &&
                        v.ValueObject is MarkdownSettings Settings)
                    {
                        Doc = await MarkdownDocument.CreateAsync(sb.ToString(), Settings);
                    }
                    else
                        Doc = await MarkdownDocument.CreateAsync(sb.ToString());
 
                    await Doc.RenderDocument(Renderer);
                }
 
                await Renderer.RenderObject(Result, true, Variables);
            }
            catch (Exception ex)
            {
                Renderer.Clear();
                await Renderer.RenderObject(ex, true, Variables);
            }
            finally
            {
                Variables.OnPreview -= Preview;
            }
 
            await asyncHtmlOutput.ReportResult(MarkdownOutputType.Html, Id, Renderer.ToString(), false);
        }
 
        public async Task<bool> RenderMarkdown(MarkdownRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            Expression Script = this.BuildExpression(Rows);
            Variables Variables = Document.Settings.Variables ?? HttpServer.CreateSessionVariables();
            object Result = await this.Evaluate(Script, Variables);
 
            await Renderer.RenderObject(Result, true, Variables);
 
            return true;
        }
 
        public async Task<bool> RenderText(TextRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            Expression Script = this.BuildExpression(Rows);
            Variables Variables = Document.Settings.Variables ?? HttpServer.CreateSessionVariables();
            object Result = await this.Evaluate(Script, Variables);
 
            await Renderer.RenderObject(Result, true);
 
            return true;
        }
 
        public async Task<bool> RenderWpfXaml(WpfXamlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            Expression Script = this.BuildExpression(Rows);
            Variables Variables = Document.Settings.Variables ?? HttpServer.CreateSessionVariables();
            object Result = await this.Evaluate(Script, Variables);
 
            await Renderer.RenderObject(Result, true, Variables);
 
            return true;
        }
 
        public async Task<bool> RenderXamarinFormsXaml(XamarinFormsXamlRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            Expression Script = this.BuildExpression(Rows);
            Variables Variables = Document.Settings.Variables ?? HttpServer.CreateSessionVariables();
            object Result = await this.Evaluate(Script, Variables);
 
            await Renderer.RenderObject(Result, true, Variables);
 
            return true;
        }
 
        public async Task<bool> RenderLatex(LatexRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            Expression Script = this.BuildExpression(Rows);
            Variables Variables = Document.Settings.Variables ?? HttpServer.CreateSessionVariables();
            object Result = await this.Evaluate(Script, Variables);
 
            await Renderer.RenderObject(Result, true, Variables);
 
            return true;
        }
 
        public async Task<bool> RenderContractXml(ContractsRenderer Renderer, string[] Rows, string Language, int Indent, MarkdownDocument Document)
        {
            Expression Script = this.BuildExpression(Rows);
            Variables Variables = Document.Settings.Variables ?? HttpServer.CreateSessionVariables();
            object Result = await this.Evaluate(Script, Variables);
 
            await Renderer.RenderObject(Result, true, Variables);
 
            return true;
        }
 
    }
}