HtmlElement.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using Waher.Runtime.Collections;
 
namespace Waher.Content.Html
{
    public class HtmlElement : HtmlNode
    {
        private Dictionary<string, HtmlAttribute> attributesByName = null;
        private ChunkedList<HtmlAttribute> attributes = null;
        private Dictionary<string, HtmlAttribute> namespacesByPrefix = null;
        private ChunkedList<HtmlNode> children = null;
        private readonly string fullName;
        private readonly string localName;
        private readonly string prefix;
        private readonly bool hasPrefix;
        private string @namespace;
 
        public HtmlElement(HtmlDocument Document, HtmlElement Parent, int StartPosition, string Name)
            : base(Document, Parent, StartPosition)
        {
            SplitName(Name, out this.prefix, out this.localName, out this.hasPrefix);
            this.fullName = Name;
            this.@namespace = null;
        }
 
        public string FullName => this.fullName;
 
        public string LocalName => this.localName;
 
        public string Prefix => this.prefix;
 
        public bool HasPrefix => this.hasPrefix;
 
        public string Namespace => this.@namespace;
 
        internal void Add(HtmlNode Node)
        {
            if (this.children is null)
                this.children = new ChunkedList<HtmlNode>();
 
            this.children.Add(Node);
        }
 
        internal void AddAttribute(HtmlAttribute Attribute)
        {
            if (!Attribute.HasPrefix && Attribute.LocalName == "xmlns")
            {
                if (string.IsNullOrEmpty(this.@namespace))
                    this.@namespace = Attribute.Value;
            }
            else if (Attribute.HasPrefix && Attribute.Prefix == "xmlns")
            {
                if (this.namespacesByPrefix is null)
                    this.namespacesByPrefix = new Dictionary<string, HtmlAttribute>();
 
                this.namespacesByPrefix[Attribute.LocalName] = Attribute;
            }
            else
            {
                if (this.attributes is null)
                {
                    this.attributes = new ChunkedList<HtmlAttribute>();
                    this.attributesByName = new Dictionary<string, HtmlAttribute>(StringComparer.OrdinalIgnoreCase);
                }
 
                if (!this.attributesByName.ContainsKey(Attribute.FullName))
                {
                    this.attributes.Add(Attribute);
                    this.attributesByName[Attribute.FullName] = Attribute;
                }
            }
        }
 
        public bool HasChildren => !(this.children is null);
 
        public bool HasAttributes => !(this.attributes is null);
 
        public IEnumerable<HtmlNode> Children => this.children;
 
        public IEnumerable<HtmlAttribute> Attributes => this.attributes;
 
        public bool TryGetAttribute(string Name, out HtmlAttribute Attribute)
        {
            if (this.attributesByName is null)
            {
                Attribute = null;
                return false;
            }
            else
                return this.attributesByName.TryGetValue(Name, out Attribute);
        }
 
        public string InnerHtml
        {
            get
            {
                int? Start = null;
                int? End = null;
 
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                    {
                        if (!Start.HasValue)
                            Start = N.StartPosition;
 
                        End = N.EndPosition;
                    }
                }
 
                if (Start.HasValue && End.HasValue)
                    return this.Document.HtmlText.Substring(Start.Value, End.Value - Start.Value + 1);
                else
                    return string.Empty;
            }
        }
 
        public string InnerText
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                    {
                        if (N is HtmlText Text)
                            sb.Append(Text.InlineText);
                        else if (N is HtmlElement Element)
                            sb.Append(Element.InnerText);
                        else if (N is HtmlEntity Entity)
                            sb.Append(Entity.ToString());
                        else if (N is CDATA CDATA)
                            sb.Append(CDATA.Content);
                    }
                }
 
                return sb.ToString();
            }
        }
 
        public string StartTag
        {
            get
            {
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                        return this.Document.HtmlText.Substring(this.StartPosition, N.StartPosition - this.StartPosition);
                }
 
                return this.OuterHtml;
            }
        }
 
        public int EndPositionOfStartTag
        {
            get
            {
                if (!(this.children is null))
                {
                    foreach (HtmlNode N in this.children)
                        return N.StartPosition - 1;
                }
 
                return this.EndPosition;
            }
        }
 
        public override string ToString()
        {
            return this.StartTag;
        }
 
        public override void Export(XmlWriter Output, Dictionary<string, string> Namespaces)
        {
            ChunkedList<KeyValuePair<string, string>> NamespaceBak = null;
 
            if (!(this.namespacesByPrefix is null))
            {
                foreach (KeyValuePair<string, HtmlAttribute> P in this.namespacesByPrefix)
                {
                    if (Namespaces.TryGetValue(P.Key, out string s))
                    {
                        if (NamespaceBak is null)
                            NamespaceBak = new ChunkedList<KeyValuePair<string, string>>();
 
                        NamespaceBak.Add(new KeyValuePair<string, string>(P.Key, s));
                    }
 
                    Namespaces[P.Key] = P.Value.Value;
                }
            }
 
            if (this.hasPrefix)
            {
                if (Namespaces.TryGetValue(this.prefix, out string s))
                    Output.WriteStartElement(this.prefix, this.localName, s);
                else
                    Output.WriteStartElement(this.prefix, this.localName, this.@namespace);
            }
            else if (this.@namespace is null)
                Output.WriteStartElement(this.localName);
            else
                Output.WriteStartElement(this.localName, this.@namespace);
 
            if (!(this.attributes is null))
            {
                foreach (HtmlAttribute Attr in this.attributes)
                    Attr.Export(Output, Namespaces);
            }
 
            if (!(this.namespacesByPrefix is null))
            {
                foreach (KeyValuePair<string, HtmlAttribute> P in this.namespacesByPrefix)
                    P.Value.Export(Output, Namespaces);
            }
 
            if (!(this.children is null))
            {
                foreach (HtmlNode Child in this.children)
                    Child.Export(Output, Namespaces);
            }
 
            Output.WriteEndElement();
 
            if (!(this.namespacesByPrefix is null))
            {
                foreach (KeyValuePair<string, HtmlAttribute> P in this.namespacesByPrefix)
                    Namespaces.Remove(P.Key);
            }
 
            if (!(NamespaceBak is null))
            {
                foreach (KeyValuePair<string, string> P in NamespaceBak)
                    Namespaces[P.Key] = P.Value;
            }
        }
 
        public override void Export(StringBuilder Output)
        {
            Output.Append('<');
            Output.Append(this.fullName);
 
            if (!(this.attributes is null))
            {
                foreach (HtmlAttribute Attr in this.attributes)
                    Attr.Export(Output);
            }
 
            if (!(this.@namespace is null))
            {
                Output.Append(" xmlns=\"");
                Output.Append(Xml.XML.Encode(this.@namespace));
                Output.Append('"');
            }
 
            if (!(this.namespacesByPrefix is null))
            {
                foreach (KeyValuePair<string, HtmlAttribute> P in this.namespacesByPrefix)
                    P.Value.Export(Output);
            }
 
            if (this.children is null)
                Output.Append("/>");
            else
            {
                Output.Append('>');
 
                foreach (HtmlNode Child in this.children)
                    Child.Export(Output);
 
                Output.Append("</");
                Output.Append(this.fullName);
                Output.Append('>');
            }
        }
 
        public virtual bool IsEmptyElement => false;
 
        public bool HasAttribute(string Name)
        {
            if (Name.StartsWith("xmlns"))
            {
                if (Name == "xmlns")
                    return !(this.@namespace is null);
 
                if (Name.Length > 6 && Name[5] == ':')
                {
                    if (this.namespacesByPrefix is null)
                        return false;
 
                    return this.namespacesByPrefix.ContainsKey(Name.Substring(6));
                }
            }
 
            if (this.attributes is null)
                return false;
 
            foreach (HtmlAttribute Attr in this.attributes)
            {
                if (string.Compare(Attr.FullName, Name, true) == 0)
                    return true;
            }
 
            return false;
        }
 
        public string GetAttribute(string Name)
        {
            if (Name.StartsWith("xmlns"))
            {
                if (Name == "xmlns")
                    return this.@namespace;
 
                if (Name.Length > 6 && Name[5] == ':')
                {
                    if (this.namespacesByPrefix is null)
                        return string.Empty;
 
                    if (this.namespacesByPrefix.TryGetValue(Name.Substring(6), out HtmlAttribute NsAttr))
                        return NsAttr.Value;
                    else
                        return string.Empty;
                }
            }
 
            if (this.attributesByName is null)
                return string.Empty;
 
            if (this.attributesByName.TryGetValue(Name, out HtmlAttribute Attr))
                return Attr.Value;
            else
                return string.Empty;
        }
 
        public string this[string Name] => this.GetAttribute(Name);
    }
}