/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.databind.io.xml;
   
   import org.codehaus.stax2.XMLEventReader2;
   import org.codehaus.stax2.XMLStreamWriter2;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NamedNodeMap;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  
  import java.util.Iterator;
  
  import javax.xml.XMLConstants;
  import javax.xml.namespace.QName;
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.stream.XMLStreamConstants;
  import javax.xml.stream.XMLStreamException;
  import javax.xml.stream.events.Attribute;
  import javax.xml.stream.events.Characters;
  import javax.xml.stream.events.Namespace;
  import javax.xml.stream.events.StartElement;
  import javax.xml.stream.events.XMLEvent;
  
  import edu.umd.cs.findbugs.annotations.NonNull;
  
  /**
   * Utility methods for converting between StAX events and W3C DOM elements.
   *
   * <p>
   * These methods support the {@code any} content feature by converting unmodeled
   * XML content between the StAX event stream used during parsing and the DOM
   * representation stored in {@link XmlAnyContent}.
   */
  public final class XmlDomUtil {
  
    private XmlDomUtil() {
      // disable construction
    }
  
    /**
     * Read an XML element from a StAX event reader and return it as a DOM
     * {@link Element}.
     *
     * <p>
     * The reader must be positioned so that the next event is a
     * {@link XMLStreamConstants#START_ELEMENT}. After this method returns, the
     * reader will be positioned just past the matching
     * {@link XMLStreamConstants#END_ELEMENT}.
     *
     * @param reader
     *          the StAX event reader, positioned before a start element
     * @return the DOM element containing the full subtree
     * @throws XMLStreamException
     *           if an error occurs while reading XML events
     */
    @NonNull
    public static Element staxToElement(@NonNull XMLEventReader2 reader)
        throws XMLStreamException {
      Document doc = newDocument();
      XMLEvent event = reader.nextEvent();
      if (!event.isStartElement()) {
        throw new XMLStreamException("Expected START_ELEMENT but found " + event.getEventType());
      }
      StartElement startElement = event.asStartElement();
      Element root = createDomElement(doc, startElement);
      doc.appendChild(root);
  
      readChildren(reader, doc, root);
      return root;
    }
  
    /**
     * Write a DOM {@link Element} to a StAX stream writer.
     *
     * <p>
     * This writes the complete element subtree including attributes, namespace
     * declarations, child elements, and text content.
     *
     * @param element
     *          the DOM element to write
     * @param writer
     *          the StAX stream writer to write to
     * @throws XMLStreamException
     *           if an error occurs while writing to the stream
     */
    public static void elementToStax(
        @NonNull Element element,
        @NonNull XMLStreamWriter2 writer)
        throws XMLStreamException {
      String namespaceUri = element.getNamespaceURI();
      String localName = element.getLocalName();
      String prefix = element.getPrefix();
 
     if (namespaceUri != null && !namespaceUri.isEmpty()) {
       if (prefix != null && !prefix.isEmpty()) {
         writer.writeStartElement(prefix, localName, namespaceUri);
         // Declare the namespace if the writer doesn't know about it
         String existingPrefix = writer.getNamespaceContext().getPrefix(namespaceUri);
         if (existingPrefix == null || !existingPrefix.equals(prefix)) {
           writer.writeNamespace(prefix, namespaceUri);
         }
       } else {
         writer.writeStartElement(namespaceUri, localName);
       }
     } else {
       writer.writeStartElement(localName);
     }
 
     // Write attributes
     writeAttributes(element, writer);
 
     // Write child nodes
     writeChildren(element, writer);
 
     writer.writeEndElement();
   }
 
   @NonNull
   private static Document newDocument() throws XMLStreamException {
     try {
       DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
       dbf.setNamespaceAware(true);
       // Harden against XXE: deny external DTD and schema access
       dbf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
       dbf.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
       DocumentBuilder builder = dbf.newDocumentBuilder();
       return builder.newDocument();
     } catch (ParserConfigurationException ex) {
       throw new XMLStreamException("Failed to create DOM DocumentBuilder", ex);
     }
   }
 
   @NonNull
   private static Element createDomElement(
       @NonNull Document doc,
       @NonNull StartElement startElement) {
     QName name = startElement.getName();
     String namespaceUri = name.getNamespaceURI();
     String localName = name.getLocalPart();
     String prefix = name.getPrefix();
 
     Element element;
     if (namespaceUri != null && !namespaceUri.isEmpty()) {
       String qualifiedName = (prefix != null && !prefix.isEmpty())
           ? prefix + ":" + localName
           : localName;
       element = doc.createElementNS(namespaceUri, qualifiedName);
     } else {
       element = doc.createElement(localName);
     }
 
     // Copy attributes
     @SuppressWarnings("unchecked")
     Iterator<Attribute> attrs = startElement.getAttributes();
     while (attrs.hasNext()) {
       Attribute attr = attrs.next();
       QName attrName = attr.getName();
       String attrNs = attrName.getNamespaceURI();
       String attrLocal = attrName.getLocalPart();
       String attrPrefix = attrName.getPrefix();
 
       if (attrNs != null && !attrNs.isEmpty()) {
         String attrQualified = (attrPrefix != null && !attrPrefix.isEmpty())
             ? attrPrefix + ":" + attrLocal
             : attrLocal;
         element.setAttributeNS(attrNs, attrQualified, attr.getValue());
       } else {
         element.setAttribute(attrLocal, attr.getValue());
       }
     }
 
     // Copy namespace declarations as xmlns attributes
     @SuppressWarnings("unchecked")
     Iterator<Namespace> namespaces = startElement.getNamespaces();
     while (namespaces.hasNext()) {
       Namespace ns = namespaces.next();
       String nsPrefix = ns.getPrefix();
       if (nsPrefix != null && !nsPrefix.isEmpty()) {
         element.setAttributeNS(
             "http://www.w3.org/2000/xmlns/",
             "xmlns:" + nsPrefix,
             ns.getNamespaceURI());
       }
       // default namespace is handled by createElementNS
     }
 
     return element;
   }
 
   private static void readChildren(
       @NonNull XMLEventReader2 reader,
       @NonNull Document doc,
       @NonNull Element parent) throws XMLStreamException {
     while (reader.hasNext()) {
       XMLEvent event = reader.peek();
       if (event.isEndElement()) {
         // Consume the end element and return
         reader.nextEvent();
         return;
       } else if (event.isStartElement()) {
         StartElement childStart = reader.nextEvent().asStartElement();
         Element child = createDomElement(doc, childStart);
         parent.appendChild(child);
         readChildren(reader, doc, child);
       } else if (event.isCharacters()) {
         Characters chars = reader.nextEvent().asCharacters();
         parent.appendChild(doc.createTextNode(chars.getData()));
       } else {
         // Skip other event types (comments, processing instructions, etc.)
         reader.nextEvent();
       }
     }
   }
 
   private static void writeAttributes(
       @NonNull Element element,
       @NonNull XMLStreamWriter2 writer) throws XMLStreamException {
     NamedNodeMap attrs = element.getAttributes();
     for (int i = 0; i < attrs.getLength(); i++) {
       Node attr = attrs.item(i);
       String attrNs = attr.getNamespaceURI();
       // getLocalName() may return null for attributes created without
       // namespace awareness; fall back to getNodeName()
       String attrName = attr.getLocalName();
       if (attrName == null) {
         attrName = attr.getNodeName();
       }
       String attrValue = attr.getNodeValue();
 
       // Skip xmlns declarations - they are handled by
       // writeStartElement/writeNamespace
       if ("http://www.w3.org/2000/xmlns/".equals(attrNs)) {
         continue;
       }
 
       if (attrNs != null && !attrNs.isEmpty()) {
         String attrPrefix = attr.getPrefix();
         if (attrPrefix != null && !attrPrefix.isEmpty()) {
           writer.writeAttribute(attrPrefix, attrNs, attrName, attrValue);
         } else {
           writer.writeAttribute(attrNs, attrName, attrValue);
         }
       } else {
         writer.writeAttribute(attrName, attrValue);
       }
     }
   }
 
   private static void writeChildren(
       @NonNull Element element,
       @NonNull XMLStreamWriter2 writer) throws XMLStreamException {
     NodeList children = element.getChildNodes();
     for (int i = 0; i < children.getLength(); i++) {
       Node child = children.item(i);
       switch (child.getNodeType()) {
       case Node.ELEMENT_NODE:
         elementToStax((Element) child, writer);
         break;
       case Node.TEXT_NODE:
         writer.writeCharacters(child.getTextContent());
         break;
       case Node.CDATA_SECTION_NODE:
         writer.writeCData(child.getTextContent());
         break;
       default:
         // Skip other node types
         break;
       }
     }
   }
 }