XmlElement.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way  
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System.Collections.Generic;
using System.Linq;
using System.Xml;
 
namespace NanoXLSX.Utils.Xml
{
    // TODO Set to internal in next major release
    public class XmlElement
    {
        private readonly bool hasPrefix;
        private bool hasNameSpaces;
        private bool hasDefaultNameSpace;
        private bool hasAttributes;
        private bool hasInnerValue;
        private bool hasChildren;
        private string innerValue;
        private string defaultXmlNsUri;

        public string Prefix { get; set; }
        public string Name { get; private set; }
        public List<XmlElement> Children { get; private set; }
        public HashSet<XmlAttribute> Attributes { get; private set; }
        public Dictionary<string, string> PrefixNameSpaceMap { get; private set; }

        public string InnerValue
        {
            get => innerValue;
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    innerValue = null;
                    hasInnerValue = false;
                }
                else
                {
                    innerValue = value;
                    hasInnerValue = true;
                }
            }
        }

        internal XmlElement(string name, string prefix)
        {
            this.Name = name;
            this.Prefix = prefix;
            this.hasPrefix = !string.IsNullOrEmpty(prefix);
        }

        internal void AddNameSpaceAttribute(string prefix, string rootNameSpace, string uri)
        {
            if (string.IsNullOrEmpty(prefix) || string.IsNullOrEmpty(uri))
            {
                return;
            }
            if (PrefixNameSpaceMap == null)
            {
                PrefixNameSpaceMap = new Dictionary<string, string>();
            }
            if (!PrefixNameSpaceMap.ContainsKey(prefix))
            {
                PrefixNameSpaceMap.Add(prefix, uri);
            }
            hasNameSpaces = true;
            AddAttribute(prefix, uri, rootNameSpace);
        }

        internal void AddDefaultXmlNameSpace(string defaultXmlNsUri)
        {
            this.defaultXmlNsUri = defaultXmlNsUri;
            hasDefaultNameSpace = true;
        }

        internal void AddAttribute(string name, string value, string prefix = "")
        {
            if (!hasAttributes)
            {
                Attributes = new HashSet<XmlAttribute>();
                hasAttributes = true;
            }
            Attributes.Add(XmlAttribute.CreateAttribute(name, value, prefix));
        }

        internal void AddAttribute(XmlAttribute? nullableAttribute)
        {
            if (!nullableAttribute.HasValue)
            {
                return;
            }
            if (!hasAttributes)
            {
                Attributes = new HashSet<XmlAttribute>();
                hasAttributes = true;
            }
            Attributes.Add(nullableAttribute.Value);
        }

        internal void AddAttributes(IEnumerable<XmlAttribute> attributes)
        {
            if (attributes == null || !attributes.Any())
            {
                return;
            }
            if (!hasAttributes)
            {
                Attributes = new HashSet<XmlAttribute>();
                hasAttributes = true;
            }
            foreach (XmlAttribute attribute in attributes)
            {
                Attributes.Add(attribute);
            }
        }

        internal XmlElement AddChildElementWithAttribute(string name, string attributeName, string attributeValue, string namePrefix = "", string attributePrefix = "")
        {
            XmlElement childElement = CreateElementWithAttribute(name, attributeName, attributeValue, namePrefix, attributePrefix);
            AddChildElement(childElement);
            return childElement;
        }

        internal XmlElement AddChildElementWithValue(string name, string innerValue, string prefix = "")
        {
            if (string.IsNullOrEmpty(innerValue))
            {
                return null; // Omit empty nodes
            }
            XmlElement childElement = CreateElement(name, prefix);
            childElement.InnerValue = innerValue;
            AddChildElement(childElement);
            return childElement;
        }

        internal XmlElement AddChildElement(string name, string prefix = "")
        {
            XmlElement childElement = CreateElement(name, prefix);
            AddChildElement(childElement);
            return childElement;
        }

        internal void AddChildElement(XmlElement xmlElement)
        {
            if (xmlElement == null)
            {
                return;
            }
            if (!hasChildren)
            {
                Children = new List<XmlElement>();
                hasChildren = true;
            }
            Children.Add(xmlElement);
        }

        internal void AddChildElements(IEnumerable<XmlElement> xmlElements)
        {
            if (xmlElements == null || !xmlElements.Any())
            {
                return;
            }
            if (!hasChildren)
            {
                Children = new List<XmlElement>();
                hasChildren = true;
            }
            Children.AddRange(xmlElements);
        }

        internal void AddChildElementBefore(XmlElement xmlElement, params string[] ancestors)
        {
            if (xmlElement == null)
            {
                return;
            }
            if (hasChildren && ancestors != null)
            {
                for (int ancestorIndex = 0; ancestorIndex < ancestors.Length; ancestorIndex++)
                {
                    for (int childIndex = 0; childIndex < Children.Count; childIndex++)
                    {
                        if (Children[childIndex].Name == ancestors[ancestorIndex])
                        {
                            Children.Insert(childIndex, xmlElement);
                            return;
                        }
                    }
                }
            }
            throw new NanoXLSX.Exceptions.IOException("None of the specified ancestor elements were found");
        }

        internal void AddChildElementAfter(XmlElement xmlElement, params string[] successors)
        {
            if (xmlElement == null)
            {
                return;
            }
            if (hasChildren && successors != null)
            {
                for (int successorIndex = 0; successorIndex < successors.Length; successorIndex++)
                {
                    for (int childIndex = Children.Count - 1; childIndex >= 0; childIndex--)
                    {
                        if (Children[childIndex].Name == successors[successorIndex])
                        {
                            Children.Insert(childIndex + 1, xmlElement);
                            return;
                        }
                    }
                }
            }
            throw new NanoXLSX.Exceptions.IOException("None of the specified successor elements were found");
        }

        public XmlDocument TransformToDocument()
        {
            XmlDocument doc = new XmlDocument
            {
                XmlResolver = null
            };
            XmlNamespaceManager nsManager = new XmlNamespaceManager(doc.NameTable);
            if (hasNameSpaces)
            {
                foreach (KeyValuePair<string, string> nameSpace in PrefixNameSpaceMap)
                {
                    if (nameSpace.Key == "xmlns")
                    {
                        continue;
                    }
                    nsManager.AddNamespace(nameSpace.Key, nameSpace.Value);
                }
            }
            // Create the root element from this instance recursively.
            System.Xml.XmlElement rootElement = null;
            if (hasDefaultNameSpace)
            {
                rootElement = XmlElement.CreateXmlElement(doc, this, nsManager, defaultXmlNsUri);
            }
            else
            {
                rootElement = XmlElement.CreateXmlElement(doc, this, nsManager);
            }
            doc.AppendChild(rootElement);
            return doc;
        }

        internal void WriteTo(XmlWriter writer, string defaultNs = null)
        {
            string elementDefaultNs = hasDefaultNameSpace ? defaultXmlNsUri : defaultNs;
 
            if (hasPrefix)
            {
                string nsUri = null;
                if (PrefixNameSpaceMap != null && PrefixNameSpaceMap.TryGetValue(Prefix, out string prefixNs))
                {
                    nsUri = prefixNs;
                }
                writer.WriteStartElement(Prefix, Name, nsUri);
            }
            else
            {
                writer.WriteStartElement(Name, elementDefaultNs);
            }
 
            if (hasNameSpaces && PrefixNameSpaceMap != null)
            {
                foreach (KeyValuePair<string, string> ns in PrefixNameSpaceMap)
                {
                    if (ns.Key == "xmlns")
                    {
                        continue;
                    }
                    writer.WriteAttributeString("xmlns", ns.Key, null, ns.Value);
                }
            }
 
            if (hasAttributes)
            {
                foreach (XmlAttribute attr in Attributes)
                {
                    if (attr.HasPrefix)
                    {
                        if (attr.Prefix == "xmlns")
                        {
                            continue;
                        }
                        string attrNsUri = null;
                        if (PrefixNameSpaceMap != null && PrefixNameSpaceMap.TryGetValue(attr.Prefix, out string mapped))
                        {
                            attrNsUri = mapped;
                        }
                        writer.WriteAttributeString(attr.Prefix, attr.Name, attrNsUri, attr.Value);
                    }
                    else
                    {
                        int colonIndex = attr.Name.IndexOf(':');
                        if (colonIndex > 0)
                        {
                            // Qualified attribute name encoded as a single string (e.g. "mc:Ignorable").
                            // XmlWriter requires the prefix and local name to be supplied separately.
                            string implicitPrefix = attr.Name.Substring(0, colonIndex);
                            string localName = attr.Name.Substring(colonIndex + 1);
                            string nsUri = null;
                            if (PrefixNameSpaceMap != null && PrefixNameSpaceMap.TryGetValue(implicitPrefix, out string mappedNs))
                            {
                                nsUri = mappedNs;
                            }
                            writer.WriteAttributeString(implicitPrefix, localName, nsUri, attr.Value);
                        }
                        else
                        {
                            writer.WriteAttributeString(attr.Name, attr.Value);
                        }
                    }
                }
            }
 
            if (hasInnerValue)
            {
                writer.WriteString(innerValue);
            }
 
            if (hasChildren)
            {
                foreach (XmlElement child in Children)
                {
                    child.WriteTo(writer, elementDefaultNs);
                }
            }
 
            writer.WriteEndElement();
        }

        public IEnumerable<XmlElement> FindChildElementsByName(string name)
        {
            if (!hasChildren)
            {
                return Enumerable.Empty<XmlElement>();
            }
            List<XmlElement> result = new List<XmlElement>();
            foreach (XmlElement child in Children)
            {
                if (child.Name == name)
                {
                    result.Add(child);
                }
                result.AddRange(child.FindChildElementsByName(name));
            }
            return result;
        }

        public IEnumerable<XmlElement> FindChildElementsByNameAndAttribute(string elementName, string attributeName)
        {
            return FindChildElementsByNameAndAttribute(elementName, attributeName, null, false);
        }

        public IEnumerable<XmlElement> FindChildElementsByNameAndAttribute(string elementName, string attributeName, string attributeValue)
        {
            return FindChildElementsByNameAndAttribute(elementName, attributeName, attributeValue, true);
        }

        private IEnumerable<XmlElement> FindChildElementsByNameAndAttribute(string elementName, string attributeName, string attributeValue, bool useValue)
        {
            if (!hasChildren)
            {
                return Enumerable.Empty<XmlElement>();
            }
            List<XmlElement> result = new List<XmlElement>();
            foreach (XmlElement child in Children)
            {
                if (child.Name == elementName && child.hasAttributes)
                {
                    XmlAttribute? attribute = XmlAttribute.FindAttribute(attributeName, child.Attributes);
                    if (attribute != null)
                    {
                        if (!useValue || (useValue && attribute.Value.Value == attributeValue))
                        {
                            result.Add(child);
                        }
                    }
                }
                result.AddRange(child.FindChildElementsByNameAndAttribute(elementName, attributeName, attributeValue, useValue));
            }
            return result;
        }

        internal static XmlElement CreateElement(string name, string prefix = "")
        {
            return new XmlElement(name, prefix);
        }

        internal static XmlElement CreateElementWithAttribute(string name, string attributeName, string attributeValue, string namePrefix = "", string attributePrefix = "")
        {
            XmlElement element = new XmlElement(name, namePrefix)
            {
                Attributes = new HashSet<XmlAttribute>()
            };
            element.Attributes.Add(XmlAttribute.CreateAttribute(attributeName, attributeValue, attributePrefix));
            element.hasAttributes = true;
            return element;
        }

        private static System.Xml.XmlElement CreateXmlElement(XmlDocument doc, XmlElement customElement, XmlNamespaceManager nsManager, string defaultXmlNsUri = null)
        {
            System.Xml.XmlElement xmlElem;
            if (customElement.hasPrefix)
            {
                xmlElem = doc.CreateElement(customElement.Prefix, customElement.Name, nsManager.LookupNamespace(customElement.Prefix));
            }
            else
            {
                xmlElem = doc.CreateElement(customElement.Name, defaultXmlNsUri);
            }
 
            // Add attributes
            if (customElement.hasAttributes)
            {
                foreach (var attr in customElement.Attributes)
                {
                    if (attr.HasPrefix)
                    {
                        System.Xml.XmlAttribute xmlAttr = doc.CreateAttribute(attr.Prefix, attr.Name, nsManager.LookupNamespace(attr.Prefix));
                        xmlAttr.Value = attr.Value;
                        xmlElem.Attributes.Append(xmlAttr);
                    }
                    else
                    {
                        xmlElem.SetAttribute(attr.Name, attr.Value);
                    }
                }
            }
 
            // Set inner text if available
            if (customElement.hasInnerValue)
            {
                xmlElem.InnerText = customElement.InnerValue;
            }
 
            // Process children recursively.
            if (customElement.hasChildren)
            {
                foreach (var child in customElement.Children)
                {
                    System.Xml.XmlElement childXmlElem = XmlElement.CreateXmlElement(doc, child, nsManager, defaultXmlNsUri);
                    xmlElem.AppendChild(childXmlElem);
                }
            }
            return xmlElem;
        }
    }
}