/*
    * Copyright (c) 2002-2026 Gargoyle Software Inc.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * https://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.htmlunit.javascript.host.xml;
  
  import static org.htmlunit.BrowserVersionFeatures.JS_XSLT_TRANSFORM_INDENT;
  
  import java.io.ByteArrayOutputStream;
  import java.nio.charset.Charset;
  import java.nio.charset.StandardCharsets;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.xml.XMLConstants;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.OutputKeys;
  import javax.xml.transform.Source;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMResult;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.htmlunit.SgmlPage;
  import org.htmlunit.WebResponse;
  import org.htmlunit.WebResponseData;
  import org.htmlunit.html.DomDocumentFragment;
  import org.htmlunit.html.DomNode;
  import org.htmlunit.html.DomText;
  import org.htmlunit.http.HttpStatus;
  import org.htmlunit.javascript.HtmlUnitScriptable;
  import org.htmlunit.javascript.JavaScriptEngine;
  import org.htmlunit.javascript.configuration.JsxClass;
  import org.htmlunit.javascript.configuration.JsxConstructor;
  import org.htmlunit.javascript.configuration.JsxFunction;
  import org.htmlunit.javascript.host.dom.Document;
  import org.htmlunit.javascript.host.dom.DocumentFragment;
  import org.htmlunit.javascript.host.dom.Node;
  import org.htmlunit.util.EncodingSniffer;
  import org.htmlunit.util.XmlUtils;
  import org.htmlunit.xml.XmlPage;
  import org.w3c.dom.NodeList;
  
  /**
   * JavaScript host object for {@code XSLTProcessor}.
   *
   * @author Ahmed Ashour
   * @author Ronald Brill
   * @author MatrixNeoKozak (matrixneo2026@tutamail.com)
   *
   * @see <a href="https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor">MDN Documentation</a>
   */
  @JsxClass
  public class XSLTProcessor extends HtmlUnitScriptable {
  
      private Node style_;
      private final Map<String, Object> parameters_ = new HashMap<>();
  
      /**
       * Creates an instance of this object.
       */
      @JsxConstructor
      public void jsConstructor() {
          // nothing to do
      }
  
      /**
       * Imports the specified stylesheet into this {@code XSLTProcessor} for transformations.
       * The specified node may be either a document node or an element node. If it is a document node,
       * then the document can contain either an XSLT stylesheet or an LRE stylesheet. If it is an element
       * node, it must be the {@code xsl:stylesheet} (or {@code xsl:transform}) element of an XSLT stylesheet.
       *
       * @param style the root node of an XSLT stylesheet (may be a document node or an element node)
       */
      @JsxFunction
      public void importStylesheet(final Node style) {
          style_ = style;
      }
  
      /**
       * Transforms the given source node by applying the stylesheet imported via {@link #importStylesheet}.
       * The owner document of the output node owns the returned document.
       *
       * @param source the node to be transformed
       * @return the transformation result as an {@link XMLDocument}
       */
      @JsxFunction
     public XMLDocument transformToDocument(final Node source) {
         final XMLDocument doc = new XMLDocument();
         doc.setPrototype(getPrototype(doc.getClass()));
         doc.setParentScope(getParentScope());
 
         final Object transformResult = transform(source);
         final org.w3c.dom.Node node;
         if (transformResult instanceof org.w3c.dom.Node transformedDoc) {
             node = transformedDoc.getFirstChild();
         }
         else {
             node = null;
         }
         final XmlPage page = new XmlPage(node, getWindow().getWebWindow());
         doc.setDomNode(page);
         return doc;
     }
 
     /**
      * Performs the XSLT transformation and returns either a {@link Node} or a {@link String}.
      *
      * @param source the node to transform
      * @return the transformation result
      */
     private Object transform(final Node source) {
         try {
             final DomNode sourceDomNode = source.getDomNodeOrDie();
             Source xmlSource = new DOMSource(sourceDomNode);
 
             final DomNode xsltDomNode = style_.getDomNodeOrDie();
             final Source xsltSource = new DOMSource(xsltDomNode);
 
             final TransformerFactory transformerFactory = TransformerFactory.newInstance();
 
             // By default, the JDK turns on FSP for DOM and SAX parsers and XML schema validators,
             // which sets a number of processing limits on the processors. Conversely, by default,
             // the JDK turns off FSP for transformers and XPath, which enables extension functions for XSLT and XPath.
             transformerFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
             try {
                 transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
             }
             catch (final IllegalArgumentException ignored) {
                 // ignore
             }
             try {
                 transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
             }
             catch (final IllegalArgumentException ignored) {
                 // ignore
             }
 
             final SgmlPage page = sourceDomNode.getPage();
             if (page != null && page.getWebClient().getBrowserVersion()
                                             .hasFeature(JS_XSLT_TRANSFORM_INDENT)) {
                 final DomNode outputNode = findOutputNode(xsltDomNode);
                 if (outputNode != null) {
                     final org.w3c.dom.Node indentNode = outputNode.getAttributes().getNamedItem("indent");
                     if (indentNode != null && "yes".equalsIgnoreCase(indentNode.getNodeValue())) {
                         try {
                             transformerFactory.setAttribute("indent-number", Integer.valueOf(2));
                         }
                         catch (final IllegalArgumentException ignored) {
                             // ignore
                         }
                         final Transformer transformer = transformerFactory.newTransformer(xsltSource);
                         transformer.setOutputProperty(OutputKeys.INDENT, "yes");
                         try {
                             transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
                         }
                         catch (final IllegalArgumentException ignored) {
                             // ignore
                         }
 
                         for (final Map.Entry<String, Object> entry : parameters_.entrySet()) {
                             transformer.setParameter(entry.getKey(), entry.getValue());
                         }
 
                         // hack to preserve indention
                         // the transformer only accepts the OutputKeys.INDENT setting if
                         // the StreamResult is used
                         try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
                             transformer.transform(xmlSource, new StreamResult(out));
                             final WebResponseData data = new WebResponseData(out.toByteArray(),
                                     HttpStatus.OK_200, HttpStatus.OK_200_MSG, Collections.emptyList());
                             final WebResponse response = new WebResponse(data, null, 0) {
 
                                 // XmlUtils.buildDocument reads the out stream using the contentCharset
                                 // we have to provide the correct one
                                 @Override
                                 public Charset getContentCharset() {
                                     final Charset cs = EncodingSniffer.toCharset(
                                             transformer.getOutputProperty(OutputKeys.ENCODING));
                                     if (cs == null) {
                                         return StandardCharsets.UTF_8;
                                     }
                                     return cs;
                                 }
                             };
                             return XmlUtils.buildDocument(response);
                         }
                     }
                 }
             }
 
             final Transformer transformer = transformerFactory.newTransformer(xsltSource);
             transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
 
             for (final Map.Entry<String, Object> entry : parameters_.entrySet()) {
                 transformer.setParameter(entry.getKey(), entry.getValue());
             }
 
             final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
             try {
                 factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
             }
             catch (final javax.xml.parsers.ParserConfigurationException ignored) {
                 // ignore
             }
             final org.w3c.dom.Document containerDocument = factory.newDocumentBuilder().newDocument();
             final org.w3c.dom.Element containerElement = containerDocument.createElement("container");
             containerDocument.appendChild(containerElement);
 
             final DOMResult result = new DOMResult(containerElement);
             transformer.transform(xmlSource, result);
 
             final org.w3c.dom.Node transformedNode = result.getNode();
             final org.w3c.dom.Node transformedFirstChild = transformedNode.getFirstChild();
             if (transformedFirstChild != null && transformedFirstChild.getNodeType() == Node.ELEMENT_NODE) {
                 return transformedNode;
             }
 
             // output is not DOM (text)
             xmlSource = new DOMSource(source.getDomNodeOrDie());
             try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
                 transformer.transform(xmlSource, new StreamResult(out));
 
                 final Charset cs = EncodingSniffer.toCharset(transformer.getOutputProperty(OutputKeys.ENCODING));
                 if (cs == null) {
                     return new String(out.toByteArray(), StandardCharsets.UTF_8);
                 }
                 return new String(out.toByteArray(), cs);
             }
         }
         catch (final RuntimeException e) {
             throw e;
         }
         catch (final Exception e) {
             throw JavaScriptEngine.reportRuntimeError("Exception: " + e);
         }
     }
 
     /**
      * Transforms the given source node by applying the imported stylesheet and appends
      * the result as children of the given output document fragment.
      *
      * @param source the node to be transformed
      * @param output the {@link Document} whose owner document is used to generate the output
      * @return the transformation result as a {@link DocumentFragment}
      */
     @JsxFunction
     public DocumentFragment transformToFragment(final Node source, final Object output) {
         final SgmlPage page = (SgmlPage) ((Document) output).getDomNodeOrDie();
 
         final DomDocumentFragment fragment = page.createDocumentFragment();
         final DocumentFragment rv = new DocumentFragment();
         rv.setPrototype(getPrototype(rv.getClass()));
         rv.setParentScope(getParentScope());
         rv.setDomNode(fragment);
 
         final Object result = transform(source);
         if (result instanceof org.w3c.dom.Node node) {
             final SgmlPage parentPage = fragment.getPage();
             final NodeList children = node.getChildNodes();
             final int length = children.getLength();
             for (int i = 0; i < length; i++) {
                 XmlUtils.appendChild(parentPage, fragment, children.item(i), true);
             }
         }
         else {
             final DomText text = new DomText(fragment.getPage(), (String) result);
             fragment.appendChild(text);
         }
 
         return rv;
     }
 
     /**
      * Sets a parameter to be used in subsequent transformations with this {@code XSLTProcessor}.
      * If the parameter does not exist in the stylesheet it will be ignored.
      *
      * @param namespaceURI the namespace URI of the XSLT parameter
      * @param localName the local name of the XSLT parameter
      * @param value the new value of the XSLT parameter
      */
     @JsxFunction
     public void setParameter(final String namespaceURI, final String localName, final Object value) {
         parameters_.put(getQualifiedName(namespaceURI, localName), value);
     }
 
     /**
      * Returns a parameter previously set by {@link #setParameter}, or {@code null} if not set.
      *
      * @param namespaceURI the namespace URI of the XSLT parameter
      * @param localName the local name of the XSLT parameter
      * @return the value of the XSLT parameter, or {@code null} if not found
      */
     @JsxFunction
     public Object getParameter(final String namespaceURI, final String localName) {
         return parameters_.get(getQualifiedName(namespaceURI, localName));
     }
 
     private static String getQualifiedName(final String namespaceURI, final String localName) {
         final String qualifiedName;
         if (namespaceURI != null && !namespaceURI.isEmpty() && !"null".equals(namespaceURI)) {
             qualifiedName = '{' + namespaceURI + '}' + localName;
         }
         else {
             qualifiedName = localName;
         }
         return qualifiedName;
     }
 
     private static DomNode findOutputNode(final DomNode xsltDomNode) {
         for (final DomNode child : xsltDomNode.getChildren()) {
             if ("output".equals(child.getLocalName())) {
                 return child;
             }
 
             for (final DomNode child1 : child.getChildren()) {
                 if ("output".equals(child1.getLocalName())) {
                     return child1;
                 }
             }
         }
         return null;
     }
 }