NestedBlock.cs

using System.Threading.Tasks;
using Waher.Content.Markdown.Rendering;
using Waher.Runtime.Collections;
using Waher.Script.Constants;
 
namespace Waher.Content.Markdown.Model.BlockElements
{
    public class NestedBlock : BlockElementChildren
    {
        private readonly bool hasBlocks = false;
 
        public NestedBlock(MarkdownDocument Document, ChunkedList<MarkdownElement> Children)
            : base(Document, Children)
        {
            this.hasBlocks = this.CalcHasBlocks();
        }
 
        public NestedBlock(MarkdownDocument Document, params MarkdownElement[] Children)
            : base(Document, Children)
        {
            this.hasBlocks = this.CalcHasBlocks();
        }
 
        private bool CalcHasBlocks()
        {
            ChunkNode<MarkdownElement> Loop = this.Children.FirstChunk;
            bool HasBlocks = false;
            bool HasSpans = false;
            bool Inconsistent = false;
            int i, c;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    if (Loop[i].IsBlockElement)
                    {
                        HasBlocks = true;
                        if (HasSpans)
                        {
                            Inconsistent = true;
                            Loop = null;
                            break;
                        }
                    }
                    else
                    {
                        HasSpans = true;
                        if (HasBlocks)
                        {
                            Inconsistent = true;
                            Loop = null;
                            break;
                        }
                    }
                }
 
                Loop = Loop?.Next;
            }
 
            if (!Inconsistent)
                return HasBlocks;
 
            ChunkedList<MarkdownElement> NewChildren = new ChunkedList<MarkdownElement>();
            ChunkedList<MarkdownElement> Spans = null;
            MarkdownElement E;
 
            Loop = this.Children.FirstChunk;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    E = Loop[i];
 
                    if (E.IsBlockElement)
                    {
                        if (!(Spans is null))
                        {
                            NewChildren.Add(new Paragraph(this.Document, Spans, true));
                            Spans = null;
                        }
 
                        NewChildren.Add(E);
                    }
                    else
                    {
                        if (Spans is null)
                            Spans = new ChunkedList<MarkdownElement>();
 
                        Spans.Add(E);
                    }
                }
 
                Loop = Loop?.Next;
            }
 
            if (!(Spans is null))
                NewChildren.Add(new Paragraph(this.Document, Spans, true));
 
            this.SetChildren(NewChildren);
 
            return true;
        }
 
        public override bool IsBlockElement => this.hasBlocks;
 
        public override Task Render(IRenderer Output) => Output.Render(this);
 
        public override bool InlineSpanElement
        {
            get
            {
                if (this.HasOneChild)
                    return this.FirstChild.InlineSpanElement;
                else
                    return false;
            }
        }
 
        public override MarkdownElementChildren Create(ChunkedList<MarkdownElement> Children, MarkdownDocument Document)
        {
            return new NestedBlock(Document, Children);
        }
 
        public override void IncrementStatistics(MarkdownStatistics Statistics)
        {
            Statistics.NrNestedBlocks++;
        }
 
    }
}