aswi20220x00-gitlab/Backend/Core/Services/HTMLService/HTMLService.cs @ a35cb648

using Core.Entities;
using Core.GraphUtils;
using Ganss.XSS;
using HtmlAgilityPack;
using Models.Tags;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Core.Services
{
    public class HTMLService : IHTMLService
    {
        /// <summary>
        /// Attribute name for uniquely identifying each tag in the HTML document on the frontend
        /// </summary>
        private const string TAG_ID_ATTRIBUTE_NAME = "aswi-tag-id";

        /// <summary>
        /// Attribute name for tag instance so that each marked out tag can be given a style
        /// </summary>
        private const string TAG_INSTANCE_ATTRIBUTE_NAME = "aswi-tag-instance";

        /// <summary>
        /// Attribute name for EF Tag IDs so that the frontend can reference them to the backend for deletion
        /// </summary>
        private const string TAG_EF_ID_ATTRIBUTE_NAME = "aswi-tag-ef-id";

        /// <summary>
        /// Info that is cached in tha database
        /// </summary>
        public class CachedInfo
        {
            /// <summary>
            /// Positions of opening tags in the original HTML document
            /// </summary>
            public List<int> TagStartPositions = new();
            /// <summary>
            /// Lengths of opening tags in the original HTML document
            /// </summary>
            public List<int> TagStartLengths = new();
            /// <summary>
            /// Positions of closing tags in the original HTML document
            /// </summary>
            public List<int> TagClosingPositions = new();
            /// <summary>
            /// Lengths for closing tags in the original HTML document
            /// </summary>
            public List<int> TagClosingLengths = new();
            /// <summary>
            /// Unused
            /// </summary>
            public Dictionary<HtmlNode, HtmlNode> NodeDict = new();
            /// <summary>
            /// Cached CSS for each tag
            /// </summary>
            public List<TagInstanceCSSInfo> TagInstanceCSS = new();
        }

        private List<int> TagStartPositions = new();
        private List<int> TagStartLengths = new();
        private List<int> TagClosingPositions = new();
        private List<int> TagClosingLengths = new();
        private Dictionary<HtmlNode, HtmlNode> NodeDict = new();
        private List<TagInstanceCSSInfo> TagInstanceCSS = new();

        /// <summary>
        /// Unpack cached info into local (request-scoped) variables
        /// </summary>
        /// <param name="cachedInfo"></param>
        private void UnpackCachedInfo(CachedInfo cachedInfo)
        {
            TagStartPositions = cachedInfo.TagStartPositions;
            TagStartLengths = cachedInfo.TagStartLengths;
            TagClosingPositions = cachedInfo.TagClosingPositions;
            TagClosingLengths = cachedInfo.TagClosingLengths;
            NodeDict = cachedInfo.NodeDict;
            TagInstanceCSS = cachedInfo.TagInstanceCSS;
        }


        /*
         *      Full HTML Preprocessing -------------------------------------------------------------------------------
         */

        public (string, CachedInfo) FullPreprocessHTML(string htmlSource, List<AnnotationTagGeneric> tags)
        {
            var docOriginal = new HtmlDocument();
            docOriginal.LoadHtml(htmlSource);
            var docToEdit = new HtmlDocument();
            docToEdit.LoadHtml(htmlSource);

            var descendantsOriginal = docOriginal.DocumentNode.DescendantsAndSelf();
            var descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();

            int currentId = 0;

            // Create mapping original-document-node -> to-edit-document-node
            FillNodeDict(descendantsOriginal, descendantsToEdit);

            // Assign IDs to all original rtags
            AssignIdsToOriginalDocument(descendantsOriginal, ref currentId);

            // Wrap all text that is not in a tag or where the parent node contains tags as children also in spans
            WrapTextInSpan(descendantsOriginal, docToEdit);

            descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();
            int descCount = descendantsToEdit.Count;

            foreach (var tag in tags)
            {
                int i = 0;
                List<HtmlNode> addedForSelection = new();
                while (i < descCount)
                {
                    for (; i < descCount; i++)
                    {
                        var node = descendantsToEdit.ElementAt(i);
                        if (!node.Name.Contains("#text") || addedForSelection.Contains(node) || addedForSelection.Contains(node.ParentNode) || node.ParentNode.Name == "style")
                        {
                            continue;
                        }

                        int nodeId = node.ParentNode.GetAttributeValue(TAG_ID_ATTRIBUTE_NAME, -1);

                        var start = TagStartPositions[nodeId] + TagStartLengths[nodeId];
                        var end = TagClosingPositions[nodeId];

                        int selectionStart = tag.Position;
                        int selectionEnd = tag.Position + tag.Length;

                        if (selectionStart < end && selectionEnd > start)
                        {
                            if (selectionStart <= start && selectionEnd >= end)
                            {
                                addedForSelection.Add(SolveFullFill(node, selectionStart, selectionEnd, start, end, docToEdit, tag));
                            }
                            else if (selectionStart <= start)
                            {
                                addedForSelection.AddRange(SolveRightGap(node, selectionStart, selectionEnd, start, end, docToEdit, tag));
                            }
                            else if (selectionEnd >= end)
                            {
                                addedForSelection.AddRange(SolveLeftGap(node, selectionStart, selectionEnd, start, end, docToEdit, tag));
                            }
                            else
                            {
                                addedForSelection.AddRange(SolveLeftRightGap(node, selectionStart, selectionEnd, start, end, docToEdit, tag));
                            }
                            descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();
                            descCount = descendantsToEdit.Count;
                            break;
                        }
                    }
                }

            }

            ModifyLinks(descendantsToEdit);
            string docToRender = docToEdit.DocumentNode.OuterHtml;
            HtmlSanitizer sanitizer = new HtmlSanitizer();
            sanitizer.AllowedAttributes.Clear();
            sanitizer.AllowedAttributes.Add(TAG_ID_ATTRIBUTE_NAME);
            sanitizer.AllowedAttributes.Add(TAG_INSTANCE_ATTRIBUTE_NAME);
            sanitizer.AllowedAttributes.Add(TAG_EF_ID_ATTRIBUTE_NAME);
            sanitizer.AllowedAttributes.Add("href");
            sanitizer.AllowedAttributes.Add("end");
            sanitizer.AllowedAttributes.Add("start");
            sanitizer.AllowedAttributes.Add("class");
            sanitizer.AllowedAttributes.Add("target");
            sanitizer.AllowedAttributes.Add("id");
            if (sanitizer.AllowedTags.Contains("script"))
            {
                sanitizer.AllowedTags.Remove("script");
            }
            if (!sanitizer.AllowedTags.Contains("style"))
            {
                sanitizer.AllowedTags.Add("style");
            }
            sanitizer.AllowedTags.Add("a");
            docToRender = sanitizer.Sanitize(docToRender);
            docToRender = docToRender.Replace("&nbsp;", " ");
            GenerateCSS(tags);

            return (docToRender, new CachedInfo()
            {
                TagStartPositions = TagStartPositions,
                TagClosingPositions = TagClosingPositions,
                TagStartLengths = TagStartLengths,
                TagClosingLengths = TagClosingLengths,
                TagInstanceCSS = TagInstanceCSS,
                NodeDict = NodeDict
            });
        }

        /// <summary>
        /// Wrap text in span when the target text is the whole text of the target tag
        /// </summary>
        /// <param name="node">text node to wrap</param>
        /// <param name="selectionStart">start of the selection in the edited document</param>
        /// <param name="selectionEnd">end of the selection in the edited document</param>
        /// <param name="start">start of the node</param>
        /// <param name="end">end of the node</param>
        /// <param name="docToEdit">document to edit</param>
        /// <param name="tag">tag we are adding</param>
        /// <returns></returns>
        private HtmlNode SolveFullFill(HtmlNode node, int selectionStart, int selectionEnd, int start, int end, HtmlDocument docToEdit, AnnotationTagGeneric tag)
        {
            // full fill
            string textSelected = node.InnerText;

            var parentNode = node.ParentNode;
            int nodeIndex = parentNode.ChildNodes.IndexOf(node);
            parentNode.ChildNodes.RemoveAt(nodeIndex);

            EPosition markerPosition = EPosition.MARK_NONE;
            if (selectionEnd == end && selectionStart == start)
            {
                markerPosition = EPosition.MARK_LEFT_RIGHT;
            }
            else if (selectionEnd == end)
            {
                markerPosition = EPosition.MARK_RIGHT;
            }
            else if (selectionStart == start)
            {
                markerPosition = EPosition.MARK_LEFT;
            }

            HtmlNode spanSelected = CreateSpan(docToEdit, textSelected, TagStartPositions.Count, tag.Instance, tag.Id, start, markerPosition);
            parentNode.ChildNodes.Insert(nodeIndex, spanSelected);

            return spanSelected;
        }

        /// <summary>
        /// Wrap text in span when the target text starts at the start of the tag and leaves space on the right side
        /// </summary>
        /// <param name="node">text node to wrap</param>
        /// <param name="selectionStart">start of the selection in the edited document</param>
        /// <param name="selectionEnd">end of the selection in the edited document</param>
        /// <param name="start">start of the node</param>
        /// <param name="end">end of the node</param>
        /// <param name="docToEdit">document to edit</param>
        /// <param name="tag">tag we are adding</param>
        /// <returns></returns>
        private List<HtmlNode> SolveRightGap(HtmlNode node, int selectionStart, int selectionEnd, int start, int end, HtmlDocument docToEdit,
                                             AnnotationTagGeneric tag)
        {
            // partial fill, end gap
            string text = node.InnerText;
            string textAfter = text.Substring(Math.Min(selectionStart - start + tag.Length, text.Length));
            string textSelected = text.Substring(0, selectionEnd - start);

            var parentNode = node.ParentNode;
            int nodeIndex = parentNode.ChildNodes.IndexOf(node);
            parentNode.ChildNodes.RemoveAt(nodeIndex);

            int spanSelectedStart = start;
            int spanAfterStart = start + textSelected.Length;

            var position = EPosition.MARK_RIGHT;
            if (selectionStart == start)
            {
                position = EPosition.MARK_LEFT_RIGHT;
            }

            HtmlNode spanSelected = CreateSpan(docToEdit, textSelected, TagStartPositions.Count, tag.Instance, tag.Id, spanSelectedStart, position);
            parentNode.ChildNodes.Insert(nodeIndex, spanSelected);

            HtmlNode spanAfter = CreateSpan(docToEdit, textAfter, TagStartPositions.Count, null, null, spanAfterStart);
            parentNode.ChildNodes.Insert(nodeIndex + 1, spanAfter);

            return new() { spanSelected, spanAfter };
        }

        /// <summary>
        /// Wrap text in span when the target text ends at the end of the tag but leaves space on the left
        /// </summary>
        /// <param name="node">text node to wrap</param>
        /// <param name="selectionStart">start of the selection in the edited document</param>
        /// <param name="selectionEnd">end of the selection in the edited document</param>
        /// <param name="start">start of the node</param>
        /// <param name="end">end of the node</param>
        /// <param name="docToEdit">document to edit</param>
        /// <param name="tag">tag we are adding</param>
        /// <returns></returns>
        private List<HtmlNode> SolveLeftGap(HtmlNode node, int selectionStart, int selectionEnd, int start, int end, HtmlDocument docToEdit,
                                             AnnotationTagGeneric tag)
        {
            // partial fill, start gap
            string text = node.InnerText;
            string textBefore = text.Substring(0, selectionStart - start);
            string textSelected = text.Substring(selectionStart - start, Math.Min(tag.Length, text.Length - textBefore.Length));

            var parentNode = node.ParentNode;
            int nodeIndex = parentNode.ChildNodes.IndexOf(node);
            parentNode.ChildNodes.RemoveAt(nodeIndex);

            int spanBeforeStart = start;
            int spanSelectedStart = start + textBefore.Length;

            var position = EPosition.MARK_LEFT;
            if (selectionEnd == end)
            {
                position = EPosition.MARK_LEFT_RIGHT;
            }

            HtmlNode spanBefore = CreateSpan(docToEdit, textBefore, TagStartPositions.Count, null, null, spanBeforeStart);
            parentNode.ChildNodes.Insert(nodeIndex, spanBefore);

            HtmlNode spanSelected = CreateSpan(docToEdit, textSelected, TagStartPositions.Count, tag.Instance, tag.Id, spanSelectedStart, position);
            parentNode.ChildNodes.Insert(nodeIndex + 1, spanSelected);

            return new() { spanSelected, spanBefore };
        }

        /// <summary>
        /// Wrap text in span when the target text is contained in the node but neither starts or ends match
        /// </summary>
        /// <param name="node">text node to wrap</param>
        /// <param name="selectionStart">start of the selection in the edited document</param>
        /// <param name="selectionEnd">end of the selection in the edited document</param>
        /// <param name="start">start of the node</param>
        /// <param name="end">end of the node</param>
        /// <param name="docToEdit">document to edit</param>
        /// <param name="tag">tag we are adding</param>
        /// <returns></returns>
        private List<HtmlNode> SolveLeftRightGap(HtmlNode node, int selectionStart, int selectionEnd, int start, int end, HtmlDocument docToEdit,
                                                 AnnotationTagGeneric tag)
        {
            // partial fill, start gap end gap
            string text = node.InnerText;
            string textBefore = text.Substring(0, selectionStart - start);
            string textAfter = text.Substring(selectionStart - start + tag.Length);
            string textSelected = text.Substring(selectionStart - start, tag.Length);

            var parentNode = node.ParentNode;
            int nodeIndex = parentNode.ChildNodes.IndexOf(node);
            parentNode.ChildNodes.RemoveAt(nodeIndex);

            int spanBeforeStart = start;
            int spanSelectedStart = start + textBefore.Length;
            int spanAfterStart = start + textBefore.Length + textSelected.Length;

            HtmlNode spanBefore = CreateSpan(docToEdit, textBefore, TagStartPositions.Count, null, null, spanBeforeStart);
            parentNode.ChildNodes.Insert(nodeIndex, spanBefore);

            HtmlNode spanSelected = CreateSpan(docToEdit, textSelected, TagStartPositions.Count, tag.Instance, tag.Id, spanSelectedStart, EPosition.MARK_LEFT_RIGHT);
            parentNode.ChildNodes.Insert(nodeIndex + 1, spanSelected);

            HtmlNode spanAfter = CreateSpan(docToEdit, textAfter, TagStartPositions.Count, null, null, spanAfterStart);
            parentNode.ChildNodes.Insert(nodeIndex + 2, spanAfter);

            return new() { spanSelected, spanBefore, spanAfter };
        }

        /// <summary>
        /// Create span utility method
        /// </summary>
        /// <param name="doc">document</param>
        /// <param name="text">inner text of the span</param>
        /// <param name="tagId">ID of the tag (TAG_ID_ATTRIBUTE_NAME)</param>
        /// <param name="instanceId">ID of the instance (TAG_INSTANCE_ATTRIBUTE_NAME)</param>
        /// <param name="entityId">Id of the EF entity (TAG_EF_ID_NAME)</param>
        /// <param name="startPosition"></param>
        /// <param name="position"></param>
        /// <returns></returns>
        private HtmlNode CreateSpan(HtmlDocument doc, string text, int tagId, Guid? instanceId, Guid? entityId, int startPosition, EPosition position = EPosition.MARK_NONE)
        {
            HtmlNode span = doc.CreateElement("span");
            span.InnerHtml = text;
            TagStartPositions.Add(startPosition);
            TagStartLengths.Add(0);
            TagClosingPositions.Add(startPosition + text.Length);
            TagClosingLengths.Add(0);
            span.Attributes.Add(TAG_ID_ATTRIBUTE_NAME, tagId.ToString());

            if (instanceId != null)
            {
                span.AddClass("annotation");
                span.Attributes.Add(TAG_INSTANCE_ATTRIBUTE_NAME, instanceId.Value.ToString());
                span.Attributes.Add(TAG_EF_ID_ATTRIBUTE_NAME, entityId.ToString());
                span.Attributes.Add("id", entityId.ToString());

                if (position == EPosition.MARK_LEFT || position == EPosition.MARK_LEFT_RIGHT)
                {
                    span.Attributes.Add("start", "1");
                }
                if (position == EPosition.MARK_RIGHT || position == EPosition.MARK_LEFT_RIGHT)
                {
                    span.Attributes.Add("end", "1");
                }
            }

            return span;
        }

        private enum EPosition
        {
            MARK_LEFT = 5,
            MARK_RIGHT = 3,
            MARK_LEFT_RIGHT = 2,
            MARK_NONE = 0
        }

        /// <summary>
        /// Redirect all links
        /// </summary>
        /// <param name="descendantsOriginal"></param>
        private void ModifyLinks(IEnumerable<HtmlNode> descendantsOriginal)
        {
            foreach (var descendant in descendantsOriginal)
            {
                if (descendant.Name == "a")
                {
                    if (descendant.Attributes.Contains("href"))
                    {
                        descendant.SetAttributeValue("href", "/link?url=" + descendant.Attributes["href"].Value);
                        descendant.SetAttributeValue("target", "_blank");
                    }
                }
            }
        }

        /// <summary>
        /// Wrap all #text nodes in spans
        /// </summary>
        /// <param name="descendantsOriginal"></param>
        /// <param name="docToEdit"></param>
        private void WrapTextInSpan(IEnumerable<HtmlNode> descendantsOriginal, HtmlDocument docToEdit)
        {
            // Special case for non-html documents
            if (descendantsOriginal.Count() == 2)
            {
                var documentNode = descendantsOriginal.ElementAt(0);
                var childNode = descendantsOriginal.ElementAt(1);
                if (documentNode.Name == "#document" && childNode.Name == "#text")
                {
                    HtmlNode coveringSpan = docToEdit.CreateElement("span");
                    coveringSpan.InnerHtml = childNode.InnerHtml;
                    TagStartPositions.Add(childNode.InnerStartIndex);
                    TagStartLengths.Add(0);
                    TagClosingPositions.Add(childNode.InnerStartIndex + childNode.InnerLength);
                    TagClosingLengths.Add(0);
                    coveringSpan.Attributes.Add(TAG_ID_ATTRIBUTE_NAME, (TagStartPositions.Count - 1).ToString());

                    var parent = NodeDict[documentNode];

                    parent.ChildNodes.RemoveAt(0);
                    parent.ChildNodes.Add(coveringSpan);

                    return;
                }
            }

            foreach (var node in descendantsOriginal)
            {
                var originalNode = node;
                var toEditNode = NodeDict[node];

                if (originalNode.Name.Contains("#"))
                {
                    continue;
                }
                else
                {
                    bool onlyText = true;
                    bool onlySubtags = true;

                    foreach (var child in node.ChildNodes)
                    {
                        if (child.Name.Contains("#"))
                        {
                            onlySubtags = false;
                        }
                        else
                        {
                            onlyText = false;
                        }
                    }

                    if (onlyText || onlySubtags)
                    {
                        continue;
                    }
                    else
                    {

                        foreach (var child in node.ChildNodes)
                        {
                            if (child.Name.Contains("#text"))
                            { 
                                HtmlNode coveringSpan = docToEdit.CreateElement("span");
                                coveringSpan.InnerHtml = child.InnerHtml;
                                
                                // Add length of 0 - in they were not in the original document
                                TagStartPositions.Add(child.InnerStartIndex);
                                TagStartLengths.Add(0);
                                TagClosingPositions.Add(child.InnerStartIndex + child.InnerLength);
                                TagClosingLengths.Add(0);
                                coveringSpan.Attributes.Add(TAG_ID_ATTRIBUTE_NAME, (TagStartPositions.Count - 1).ToString());

                                var parent = NodeDict[node];
                                var index = parent.ChildNodes.IndexOf(NodeDict[child]);

                                parent.ChildNodes.RemoveAt(index);
                                parent.ChildNodes.Insert(index, coveringSpan);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Generate CSS for all tag instances
        /// </summary>
        /// <param name="tags"></param>
        private void GenerateCSS(List<AnnotationTagGeneric> tags)
        {
            /*string inner = "span.annotation {border-bottom: 2px solid;}";
            inner += "span {line-height: 30px}\n";*/

            var tagPaddingDict = Intersections.ColorGraph(Intersections.FindIntersections(tags));
            foreach (var tag in tags.DistinctBy(t => t.Instance))
            {
                var padding = (tagPaddingDict[tag] + 2) * 2;
                TagInstanceCSS.Add(new()
                {
                    InstanceId = tag.Instance,
                    Color = tag.Tag.Color,
                    Padding = padding
                });
            }
        }

        /// <summary>
        /// Add IDs to all tags in the original document
        /// </summary>
        /// <param name="descendantsOriginal"></param>
        /// <param name="currentId"></param>
        private void AssignIdsToOriginalDocument(IEnumerable<HtmlNode> descendantsOriginal, ref int currentId)
        {
            foreach (var node in descendantsOriginal)
            {
                var originalNode = node;
                var toEditNode = NodeDict[node];

                if (originalNode.Name.Contains("#"))
                {
                    continue;
                }
                else
                {
                    TagStartPositions.Add(originalNode.OuterStartIndex);
                    TagStartLengths.Add(originalNode.InnerStartIndex - originalNode.OuterStartIndex);
                    currentId = TagStartPositions.Count - 1;
                    toEditNode.Attributes.Add(TAG_ID_ATTRIBUTE_NAME, currentId.ToString());

                    // Cross-referencing of the original document to the edited document
                    TagClosingPositions.Add(originalNode.InnerStartIndex + originalNode.InnerLength);
                    TagClosingLengths.Add((originalNode.OuterStartIndex + originalNode.OuterLength) - (originalNode.InnerStartIndex + originalNode.InnerLength));
                }
            }
        }

        private void FillNodeDict(IEnumerable<HtmlNode> descendantsOriginal, IEnumerable<HtmlNode> descendantsToEdit)
        {
            var zipped = descendantsOriginal.Zip(descendantsToEdit, (orig, toEdit) => new
            {
                Original = orig,
                ToEdit = toEdit
            });
            foreach (var node in zipped)
            {
                var originalNode = node.Original;
                var toEditNode = node.ToEdit;
                NodeDict.Add(originalNode, toEditNode);
            }
        }


        /*
         *      Full HTML Preprocessing -------------------------------------------------------------------------------
         */

        /*
         *      Partial HTML Preprocessing ----------------------------------------------------------------------------
         */

        /// <summary>
        /// Incrementally modifies the html to render and cached info by adding a new tag
        /// </summary>
        /// <param name="htmlToEdit"></param>
        /// <param name="htmlOriginal"></param>
        /// <param name="tagToAdd"></param>
        /// <param name="tags"></param>
        /// <param name="cachedInfo"></param>
        /// <returns></returns>
        public (string, CachedInfo) PartialPreprocessHTMLAddTag(string htmlToEdit, string htmlOriginal, AnnotationTagGeneric tagToAdd, List<AnnotationTagGeneric> tags, CachedInfo cachedInfo)
        {
            UnpackCachedInfo(cachedInfo);

            var docOriginal = new HtmlDocument();
            docOriginal.LoadHtml(htmlOriginal);
            var docToEdit = new HtmlDocument();
            docToEdit.LoadHtml(htmlToEdit);

            var descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();

            int i = 0;
            List<HtmlNode> addedForSelection = new();

            int descendantsCount = descendantsToEdit.Count();
            while (i < descendantsCount)
            {
                for (; i < descendantsCount; i++)
                {
                    var node = descendantsToEdit.ElementAt(i);
                    if (!node.Name.Contains("#text") || addedForSelection.Contains(node) || addedForSelection.Contains(node.ParentNode) ||
                        node.ParentNode.Name == "style" || node.ParentNode.Name.StartsWith("#"))
                    {
                        continue;
                    }

                    int nodeId = node.ParentNode.GetAttributeValue(TAG_ID_ATTRIBUTE_NAME, -1);

                    var start = TagStartPositions[nodeId] + TagStartLengths[nodeId];
                    var end = TagClosingPositions[nodeId];

                    int selectionStart = tagToAdd.Position;
                    int selectionEnd = tagToAdd.Position + tagToAdd.Length;

                    if (selectionStart < end && selectionEnd > start)
                    {
                        if (selectionStart <= start && selectionEnd >= end)
                        {
                            addedForSelection.Add(SolveFullFill(node, selectionStart, selectionEnd, start, end, docToEdit, tagToAdd));
                        }
                        else if (selectionStart <= start)
                        {
                            addedForSelection.AddRange(SolveRightGap(node, selectionStart, selectionEnd, start, end, docToEdit, tagToAdd));
                        }
                        else if (selectionEnd >= end)
                        {
                            addedForSelection.AddRange(SolveLeftGap(node, selectionStart, selectionEnd, start, end, docToEdit, tagToAdd));
                        }
                        else
                        {
                            addedForSelection.AddRange(SolveLeftRightGap(node, selectionStart, selectionEnd, start, end, docToEdit, tagToAdd));
                        }
                        descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();
                        descendantsCount = descendantsToEdit.Count();
                        break;
                    }
                }
            }

            GenerateCSS(tags);
            return (docToEdit.DocumentNode.OuterHtml, new()
            {
                TagStartPositions = TagStartPositions,
                TagStartLengths = TagStartLengths,
                TagClosingPositions = TagClosingPositions,
                TagClosingLengths = TagClosingLengths,
                TagInstanceCSS = TagInstanceCSS,
                NodeDict = NodeDict
            });
        }

        /// <summary>
        /// Removing tag effectively just cleans up the attributes and CSS thus has no effect
        /// </summary>
        /// <param name="htmlToEdit"></param>
        /// <param name="htmlOriginal"></param>
        /// <param name="tagToRemove"></param>
        /// <param name="tags"></param>
        /// <param name="cachedInfo"></param>
        /// <returns></returns>
        public (string, CachedInfo) PartialPreprocessHTMLRemoveTag(string htmlToEdit, string htmlOriginal, AnnotationTagGeneric tagToRemove, List<AnnotationTagGeneric> tags, CachedInfo cachedInfo)
        {
            UnpackCachedInfo(cachedInfo);

            var docOriginal = new HtmlDocument();
            docOriginal.LoadHtml(htmlOriginal);
            var docToEdit = new HtmlDocument();
            docToEdit.LoadHtml(htmlToEdit);

            var descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();

            int i = 0;
            int descendantsCount = descendantsToEdit.Count();
            while (i < descendantsCount)
            {
                for (; i < descendantsCount; i++)
                {
                    var node = descendantsToEdit.ElementAt(i);
                    if (!node.Attributes.Contains(TAG_EF_ID_ATTRIBUTE_NAME))
                    {
                        continue;
                    }
                    else
                    {
                        if (node.Attributes[TAG_EF_ID_ATTRIBUTE_NAME].Value != tagToRemove.Id.ToString())
                        {
                            continue;
                        }

                        node.Attributes.Remove(TAG_EF_ID_ATTRIBUTE_NAME);
                        node.Attributes.Remove(TAG_INSTANCE_ATTRIBUTE_NAME);
                        node.Attributes.Remove("class");
                        node.Attributes.Remove("start");
                        node.Attributes.Remove("end");

                        descendantsToEdit = docToEdit.DocumentNode.DescendantsAndSelf().ToList();
                        descendantsCount = descendantsToEdit.Count();
                        break;
                    }
                }
            }

            GenerateCSS(tags);
            return (docToEdit.DocumentNode.OuterHtml, new()
            {
                TagStartPositions = TagStartPositions,
                TagStartLengths = TagStartLengths,
                TagClosingPositions = TagClosingPositions,
                TagClosingLengths = TagClosingLengths,
                TagInstanceCSS = TagInstanceCSS,
                NodeDict = NodeDict
            });
        }

        /*
         *      Partial HTML Preprocessing ----------------------------------------------------------------------------
         */
    }
}