TextRenderer.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Markdown.Model;
using Waher.Content.Markdown.Model.BlockElements;
using Waher.Content.Markdown.Model.SpanElements;
using Waher.Events;
using Waher.Runtime.Collections;
using Waher.Script.Constants;
 
namespace Waher.Content.Markdown.Rendering
{
    public class TextRenderer : Renderer
    {
        public TextRenderer()
            : base()
        {
        }
 
        public TextRenderer(StringBuilder Output)
            : base(Output)
        {
        }
 
        public override async Task RenderFootnotes()
        {
            this.Output.AppendLine(new string('-', 80));
            this.Output.AppendLine();
 
            foreach (string Key in this.Document.FootnoteOrder)
            {
                if ((this.Document?.TryGetFootnote(Key, out Footnote Note) ?? false) &&
                    Note.Referenced)
                {
                    this.Output.Append('[');
 
                    if (this.Document?.TryGetFootnoteNumber(Key, out int Nr) ?? false)
                        this.Output.Append(Nr.ToString());
                    else
                        this.Output.Append(Key);
 
                    this.Output.Append("] ");
 
                    await Note.Render(this);
                }
            }
        }
 
        #region Span Elements
 
        public override Task Render(Abbreviation Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(AutomaticLinkMail Element)
        {
            this.Output.Append(Element.EMail);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(AutomaticLinkUrl Element)
        {
            this.Output.Append(Element.URL);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(Delete Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(DetailsReference Element)
        {
            if (!(this.Document.Detail is null))
                return this.RenderDocument(this.Document.Detail, true);
            else
                return this.Render((MetaReference)Element);
        }
 
        public override Task Render(EmojiReference Element)
        {
            this.Output.Append(Element.Emoji.Unicode);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(Emphasize Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(FootnoteReference Element)
        {
            if (this.Document?.TryGetFootnote(Element.Key, out Footnote Footnote) ?? false)
                Footnote.Referenced = true;
 
            this.Output.Append(" [");
 
            if ((this.Document?.TryGetFootnoteNumber(Element.Key, out int Nr) ?? false))
                this.Output.Append(Nr.ToString());
            else
                this.Output.Append(Element.Key);
 
            this.Output.Append(']');
 
            return Task.CompletedTask;
        }
 
        public override Task Render(HashTag Element)
        {
            this.Output.Append(Element.Tag);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(HtmlEntity Element)
        {
            string s = Html.HtmlEntity.EntityToCharacter(Element.Entity);
            if (!string.IsNullOrEmpty(s))
                this.Output.Append(s);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(HtmlEntityUnicode Element)
        {
            this.Output.Append((char)Element.Code);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(InlineCode Element)
        {
            this.Output.Append(Element.Code);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(InlineHTML Element)
        {
            return Task.CompletedTask;
        }
 
        public override async Task Render(InlineScript Element)
        {
            object Result = await Element.EvaluateExpression();
            await this.RenderObject(Result, Element.AloneInParagraph);
        }
 
        public Task RenderObject(object Result, bool AloneInParagraph)
        {
            if (Result is null)
                return Task.CompletedTask;
 
            this.Output.Append(Result.ToString());
 
            if (AloneInParagraph)
            {
                this.Output.AppendLine();
                this.Output.AppendLine();
            }
 
            return Task.CompletedTask;
        }
 
        public override Task Render(InlineText Element)
        {
            this.Output.Append(Element.Value);
 
            return Task.CompletedTask;
        }
 
        public override Task Render(Insert Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(LineBreak Element)
        {
            this.Output.AppendLine();
 
            return Task.CompletedTask;
        }
 
        public override Task Render(Link Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(LinkReference Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(MetaReference Element)
        {
            bool FirstOnRow = true;
 
            if (Element.TryGetMetaData(out KeyValuePair<string, bool>[] Values))
            {
                foreach (KeyValuePair<string, bool> P in Values)
                {
                    if (FirstOnRow)
                        FirstOnRow = false;
                    else
                        this.Output.Append(' ');
 
                    this.Output.Append(P.Key);
                    if (P.Value)
                    {
                        this.Output.AppendLine();
                        FirstOnRow = true;
                    }
                }
            }
 
            return Task.CompletedTask;
        }
 
        public override Task Render(Model.SpanElements.Multimedia Element)
        {
            IMultimediaTextRenderer Renderer = Element.MultimediaHandler<IMultimediaTextRenderer>();
            if (Renderer is null)
                return this.DefaultRenderingMultimedia(Element.Children, Element.AloneInParagraph);
            else
                return Renderer.RenderText(this, Element.Items, Element.Children, Element.AloneInParagraph, Element.Document);
        }
 
        private async Task DefaultRenderingMultimedia(ChunkedList<MarkdownElement> ChildNodes,
            bool AloneInParagraph)
        {
            await this.Render(ChildNodes);
 
            if (AloneInParagraph)
            {
                this.Output.AppendLine();
                this.Output.AppendLine();
            }
        }
 
        public override Task Render(MultimediaReference Element)
        {
            Model.SpanElements.Multimedia Multimedia = Element.Document.GetReference(Element.Label);
 
            if (!(Multimedia is null))
            {
                IMultimediaTextRenderer Renderer = Multimedia.MultimediaHandler<IMultimediaTextRenderer>();
                if (Renderer is null)
                    return this.DefaultRenderingMultimedia(Element.Children, Element.AloneInParagraph);
                else
                    return Renderer.RenderText(this, Multimedia.Items, Element.Children, Element.AloneInParagraph, Element.Document);
            }
 
            return this.RenderChildren(Element);
        }
 
        public override Task Render(StrikeThrough Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(Strong Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(SubScript Element)
        {
            int i;
 
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Renderer.RenderChildren(Element);
 
                foreach (char ch in Renderer.ToString())
                {
                    i = nrmScriptLetters.IndexOf(ch);
                    if (i < 0)
                        this.Output.Append(ch);
                    else
                        this.Output.Append(subScriptLetters[i]);
                }
            }
        }
 
        private const string nrmScriptLetters = "0123456789+-=()aeoxhklmnpstijruv";
        private const string subScriptLetters = "₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₒₓₕₖₗₘₙₚₛₜᵢⱼᵣᵤᵥ";
 
        public static string ToSubscript(string s)
        {
            StringBuilder sb = new StringBuilder();
            int i;
 
            foreach (char ch in s)
            {
                i = nrmScriptLetters.IndexOf(ch);
                if (i < 0)
                    sb.Append(ch);
                else
                    sb.Append(subScriptLetters[i]);
            }
 
            return sb.ToString();
        }
 
        public override async Task Render(SuperScript Element)
        {
            int i;
 
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Renderer.RenderChildren(Element);
 
                foreach (char ch in Renderer.ToString())
                {
                    i = normlScriptLetters.IndexOf(ch);
                    if (i < 0)
                        this.Output.Append(ch);
                    else
                        this.Output.Append(superScriptLetters[i]);
                }
            }
        }
 
        private const string normlScriptLetters = "abcdefghijklmnoprstuvwxyzABDEGHIJKLMNOPRTUW0123456789+-=()";
        private const string superScriptLetters = "ᵃᵇᶜᵈᵉᶠᵍʰⁱʲᵏˡᵐⁿᵒᵖʳˢᵗᵘᵛʷˣʸᶻᴬᴮᴰᴱᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾᴿᵀᵁᵂ⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾";
 
        public static string ToSuperscript(string s)
        {
            StringBuilder sb = new StringBuilder();
            int i;
 
            foreach (char ch in s)
            {
                i = normlScriptLetters.IndexOf(ch);
                if (i < 0)
                    sb.Append(ch);
                else
                    sb.Append(superScriptLetters[i]);
            }
 
            return sb.ToString();
        }
 
        public override Task Render(Underline Element)
        {
            return this.RenderChildren(Element);
        }
 
        #endregion
 
        #region Block elements
 
        public override async Task Render(BlockQuote Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Renderer.RenderChildren(Element);
 
                string s = Renderer.ToString().Trim();
                s = s.Replace("\r\n", "\n").Replace("\r", "\n");
 
                foreach (string Row in s.Split('\n'))
                {
                    this.Output.Append("> ");
                    this.Output.AppendLine(Row);
                }
 
                this.Output.AppendLine();
            }
        }
 
        public override async Task Render(BulletList Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                string s;
                string s2 = Environment.NewLine + Environment.NewLine;
                bool LastIsParagraph = false;
 
                s = this.Output.ToString();
                if (!s.EndsWith(Environment.NewLine) && !string.IsNullOrEmpty(s))
                    this.Output.AppendLine();
 
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        await Loop[i].Render(Renderer);
 
                        s = Renderer.ToString();
                        Renderer.Clear();
                        this.Output.Append(s);
 
                        LastIsParagraph = s.EndsWith(s2);
                    }
 
                    Loop = Loop.Next;
                }
 
                if (!LastIsParagraph)
                    this.Output.AppendLine();
            }
        }
 
        public override Task Render(CenterAligned Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(CodeBlock Element)
        {
            ICodeContentTextRenderer Renderer = Element.CodeContentHandler<ICodeContentTextRenderer>();
 
            if (!(Renderer is null))
            {
                try
                {
                    if (await Renderer.RenderText(this, Element.Rows, Element.Language, Element.Indent, Element.Document))
                        return;
                }
                catch (Exception ex)
                {
                    ex = Log.UnnestException(ex);
 
                    if (ex is AggregateException ex2)
                    {
                        foreach (Exception ex3 in ex2.InnerExceptions)
                            this.Output.AppendLine(ex3.Message);
                    }
                    else
                        this.Output.AppendLine(ex.Message);
                }
            }
            else
            {
                int i;
 
                for (i = Element.Start; i <= Element.End; i++)
                {
                    this.Output.Append(Element.IndentString);
                    this.Output.AppendLine(Element.Rows[i]);
                }
 
                this.Output.AppendLine();
            }
        }
 
        public override Task Render(CommentBlock Element)
        {
            return Task.CompletedTask;
        }
 
        public override async Task Render(DefinitionDescriptions Element)
        {
            ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
            int i, c;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    this.Output.Append(":\t");
                    await Loop[i].Render(this);
                    this.Output.AppendLine();
                }
 
                Loop = Loop.Next;
            }
        }
 
        public override async Task Render(DefinitionList Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                string s;
                string s2 = Environment.NewLine + Environment.NewLine;
                bool LastIsParagraph = false;
                bool FirstTerm = true;
 
                s = this.Output.ToString();
                if (!s.EndsWith(Environment.NewLine) && !string.IsNullOrEmpty(s))
                    this.Output.AppendLine();
 
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                MarkdownElement E;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        E = Loop[i];
 
                        if (E is DefinitionTerms)
                        {
                            if (FirstTerm)
                                FirstTerm = false;
                            else
                                this.Output.AppendLine();
                        }
 
                        await E.Render(Renderer);
                        s = Renderer.ToString();
                        Renderer.Clear();
                        this.Output.Append(s);
 
                        LastIsParagraph = s.EndsWith(s2);
                    }
 
                    Loop = Loop.Next;
                }
                if (!LastIsParagraph)
                    this.Output.AppendLine();
            }
        }
 
        public override async Task Render(DefinitionTerms Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                string s;
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        await Loop[i].Render(Renderer);
                        s = Renderer.ToString();
                        Renderer.Clear();
                        this.Output.Append(s);
 
                        if (!s.EndsWith(Environment.NewLine))
                            this.Output.AppendLine();
                    }
 
                    Loop = Loop.Next;
                }
            }
        }
 
        public override async Task Render(DeleteBlocks Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Renderer.RenderChildren(Element);
 
                string s = Renderer.ToString().Trim();
                s = s.Replace("\r\n", "\n").Replace("\r", "\n");
 
                foreach (string Row in s.Split('\n'))
                {
                    this.Output.Append("-> ");
                    this.Output.AppendLine(Row);
                }
 
                this.Output.AppendLine();
            }
        }
 
        public override Task Render(Footnote Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(Header Element)
        {
            if (Element.Level <= 2)
            {
                int Len = this.Output.Length;
 
                await this.RenderChildren(Element);
 
                Len = this.Output.Length - Len + 3;
                this.Output.AppendLine();
                this.Output.AppendLine(new string(Element.Level == 1 ? '=' : '-', Len));
                this.Output.AppendLine();
            }
            else
            {
                this.Output.Append(new string('#', Element.Level));
                this.Output.Append(' ');
 
                await this.RenderChildren(Element);
 
                this.Output.AppendLine();
                this.Output.AppendLine();
            }
        }
 
        public override Task Render(HorizontalRule Element)
        {
            this.Output.AppendLine(new string('-', 80));
            this.Output.AppendLine();
 
            return Task.CompletedTask;
        }
 
        public override async Task Render(HtmlBlock Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                string s;
                bool First = true;
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        await Loop[i].Render(Renderer);
                        s = Renderer.ToString().TrimStart().Trim(' ');    // Only space at the end, not CRLF
                        Renderer.Clear();
 
                        if (!string.IsNullOrEmpty(s))
                        {
                            if (First)
                                First = false;
                            else
                                this.Output.Append(' ');
 
                            this.Output.Append(s);
 
                            if (s.EndsWith("\n"))
                                First = true;
                        }
                    }
 
                    Loop = Loop.Next;
                }
 
                this.Output.AppendLine();
                this.Output.AppendLine();
            }
        }
 
        public override async Task Render(InsertBlocks Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Renderer.RenderChildren(Element);
 
                string s = Renderer.ToString().Trim();
                s = s.Replace("\r\n", "\n").Replace("\r", "\n");
 
                foreach (string Row in s.Split('\n'))
                {
                    this.Output.Append("+> ");
                    this.Output.AppendLine(Row);
                }
 
                this.Output.AppendLine();
            }
        }
 
        public override Task Render(InvisibleBreak Element)
        {
            return Task.CompletedTask;
        }
 
        public override Task Render(LeftAligned Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(MarginAligned Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(NestedBlock Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override async Task Render(NumberedItem Element)
        {
            this.Output.Append(Element.Number.ToString());
            this.Output.Append(". ");
 
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Renderer.RenderChild(Element);
 
                string s = Renderer.ToString();
 
                this.Output.Append(s);
 
                if (!s.EndsWith("\n"))
                    this.Output.AppendLine();
            }
        }
 
        public override async Task Render(NumberedList Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                string s;
                string s2 = Environment.NewLine + Environment.NewLine;
                bool LastIsParagraph = false;
 
                s = this.Output.ToString();
                if (!s.EndsWith(Environment.NewLine) && !string.IsNullOrEmpty(s))
                    this.Output.AppendLine();
 
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        await Loop[i].Render(Renderer);
                        s = Renderer.ToString();
                        Renderer.Clear();
                        this.Output.Append(s);
 
                        LastIsParagraph = s.EndsWith(s2);
                    }
 
                    Loop = Loop.Next;
                }
 
                if (!LastIsParagraph)
                    this.Output.AppendLine();
            }
        }
 
        public override async Task Render(Paragraph Element)
        {
            await this.RenderChildren(Element);
 
            this.Output.AppendLine();
            this.Output.AppendLine();
        }
 
        public override Task Render(RightAligned Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(Sections Element)
        {
            return this.RenderChildren(Element);
        }
 
        public override Task Render(SectionSeparator Element)
        {
            this.Output.AppendLine(new string('=', 80));
            this.Output.AppendLine();
 
            return Task.CompletedTask;
        }
 
        public override async Task Render(Table Element)
        {
            bool First;
 
            foreach (MarkdownElement[] Row in Element.Headers)
            {
                First = true;
 
                foreach (MarkdownElement E in Row)
                {
                    if (E is null)
                        continue;
 
                    if (First)
                        First = false;
                    else
                        this.Output.Append('\t');
 
                    await E.Render(this);
                }
 
                this.Output.AppendLine();
            }
 
            foreach (MarkdownElement[] Row in Element.Rows)
            {
                First = true;
 
                foreach (MarkdownElement E in Row)
                {
                    if (E is null)
                        continue;
 
                    if (First)
                        First = false;
                    else
                        this.Output.Append('\t');
 
                    await E.Render(this);
                }
 
                this.Output.AppendLine();
            }
 
            this.Output.AppendLine();
        }
 
        public override async Task Render(TaskItem Element)
        {
            if (Element.IsChecked)
                this.Output.Append("[X] ");
            else
                this.Output.Append("[ ] ");
 
            using (TextRenderer Renderer = new TextRenderer())
            {
                await Element.Child.Render(Renderer);
 
                string s = Renderer.ToString();
 
                this.Output.Append(s);
 
                if (!s.EndsWith("\n"))
                    this.Output.AppendLine();
            }
        }
 
        public override async Task Render(TaskList Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                string s;
                string s2 = Environment.NewLine + Environment.NewLine;
                bool LastIsParagraph = false;
 
                s = this.Output.ToString();
                if (!s.EndsWith(Environment.NewLine) && !string.IsNullOrEmpty(s))
                    this.Output.AppendLine();
 
                ChunkNode<MarkdownElement> Loop = Element.Children.FirstChunk;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        await Loop[i].Render(Renderer);
                        s = Renderer.ToString();
                        Renderer.Clear();
                        this.Output.Append(s);
 
                        LastIsParagraph = s.EndsWith(s2);
                    }
 
                    Loop = Loop.Next;
                }
 
                if (!LastIsParagraph)
                    this.Output.AppendLine();
            }
        }
 
        public override async Task Render(UnnumberedItem Element)
        {
            using (TextRenderer Renderer = new TextRenderer())
            {
                this.Output.Append(Element.Prefix);
                this.Output.Append(' ');
 
                await Element.Child.Render(Renderer);
 
                string s = Renderer.ToString();
 
                this.Output.Append(s);
 
                if (!s.EndsWith("\n"))
                    this.Output.AppendLine();
            }
        }
 
        #endregion
 
    }
}