/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Copyright  1999-2004 The Apache Software Foundation.

 *

 *  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

 *

 *      http://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 com.sun.org.apache.xml.internal.security.utils;

import java.io.IOException;

import java.io.OutputStream;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import com.sun.org.apache.xml.internal.security.c14n.CanonicalizationException;

import com.sun.org.apache.xml.internal.security.c14n.Canonicalizer;

import com.sun.org.apache.xml.internal.security.c14n.InvalidCanonicalizerException;

import org.w3c.dom.Attr;

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 org.w3c.dom.Text;

/**

 * DOM and XML accessibility and comfort functions.

 *

 * @author Christian Geuer-Pollmann

 */

public class XMLUtils {

   private static boolean ignoreLineBreaks =

      AccessController.doPrivileged(new PrivilegedAction<Boolean>() {

         public Boolean run() {

            return Boolean.getBoolean

               ("com.sun.org.apache.xml.internal.security.ignoreLineBreaks");

         }

      });

   /**

    * Constructor XMLUtils

    *

    */

   private XMLUtils() {

      // we don't allow instantiation

   }

   public static Element getNextElement(Node el) {

           while ((el!=null) && (el.getNodeType()!=Node.ELEMENT_NODE)) {

                   el=el.getNextSibling();

           }

           return (Element)el;

   }

   /**

    * @param rootNode

    * @param result

    * @param exclude

    * @param com wheather comments or not

    */

          if ((exclude!=null) && isDescendantOrSelf(exclude,rootNode)){

                return;

      }

      getSetRec(rootNode,result,exclude,com);

   }

        final Node exclude ,final boolean com) {

           //Set result = new HashSet();

       if (rootNode==exclude) {

          return;

       }

           switch (rootNode.getNodeType()) {

                case Node.ELEMENT_NODE:

                                result.add(rootNode);

                        Element el=(Element)rootNode;

                if (el.hasAttributes()) {

                                NamedNodeMap nl = ((Element)rootNode).getAttributes();

                                for (int i=0;i<nl.getLength();i++) {

                                        result.add(nl.item(i));

                                }

                }

                case Node.DOCUMENT_NODE:

                                for (Node r=rootNode.getFirstChild();r!=null;r=r.getNextSibling()){

                                        if (r.getNodeType()==Node.TEXT_NODE) {

                                                result.add(r);

                                                while ((r!=null) && (r.getNodeType()==Node.TEXT_NODE)) {

                                                        r=r.getNextSibling();

                                                }

                                                if (r==null)

                                                        return;

                                        }

                                        getSetRec(r,result,exclude,com);

                                }

                                return;

                        case Node.COMMENT_NODE:

                                if (com) {

                                        result.add(rootNode);

                                }

                            return;

                        case Node.DOCUMENT_TYPE_NODE:

                                return;

                        default:

                                result.add(rootNode);

           }

           return;

   }

   /**

    * Outputs a DOM tree to an {@link OutputStream}.

    *

    * @param contextNode root node of the DOM tree

    * @param os the {@link OutputStream}

    */

   public static void outputDOM(Node contextNode, OutputStream os) {

      XMLUtils.outputDOM(contextNode, os, false);

   }

   /**

    * Outputs a DOM tree to an {@link OutputStream}. <I>If an Exception is

    * thrown during execution, it's StackTrace is output to System.out, but the

    * Exception is not re-thrown.</I>

    *

    * @param contextNode root node of the DOM tree

    * @param os the {@link OutputStream}

    * @param addPreamble

    */

   public static void outputDOM(Node contextNode, OutputStream os,

                                boolean addPreamble) {

      try {

         if (addPreamble) {

            os.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n".getBytes());

         }

         os.write(

            Canonicalizer.getInstance(

               Canonicalizer.ALGO_ID_C14N_WITH_COMMENTS).canonicalizeSubtree(

               contextNode));

      } catch (IOException ex) {}

      catch (InvalidCanonicalizerException ex) {

         ex.printStackTrace();

      } catch (CanonicalizationException ex) {

         ex.printStackTrace();

      }

   }

   /**

    * Serializes the <CODE>contextNode</CODE> into the OutputStream, <I>but

    * supresses all Exceptions</I>.

    * <BR />

    * NOTE: <I>This should only be used for debugging purposes,

    * NOT in a production environment; this method ignores all exceptions,

    * so you won't notice if something goes wrong. If you're asking what is to

    * be used in a production environment, simply use the code inside the

    * <code>try{}</code> statement, but handle the Exceptions appropriately.</I>

    *

    * @param contextNode

    * @param os

    */

   public static void outputDOMc14nWithComments(Node contextNode,

           OutputStream os) {

      try {

         os.write(

            Canonicalizer.getInstance(

               Canonicalizer.ALGO_ID_C14N_WITH_COMMENTS).canonicalizeSubtree(

               contextNode));

      } catch (IOException ex) {

         // throw new RuntimeException(ex.getMessage());

      } catch (InvalidCanonicalizerException ex) {

         // throw new RuntimeException(ex.getMessage());

      } catch (CanonicalizationException ex) {

         // throw new RuntimeException(ex.getMessage());

      }

   }

   /**

    * Method getFullTextChildrenFromElement

    *

    * @param element

    * @return the string of chi;ds

    */

   public static String getFullTextChildrenFromElement(Element element) {

      StringBuffer sb = new StringBuffer();

      NodeList children = element.getChildNodes();

      int iMax = children.getLength();

      for (int i = 0; i < iMax; i++) {

         Node curr = children.item(i);

         if (curr.getNodeType() == Node.TEXT_NODE) {

            sb.append(((Text) curr).getData());

         }

      }

      return sb.toString();

   }

   static  String dsPrefix=null;

   /**

    * Creates an Element in the XML Signature specification namespace.

    *

    * @param doc the factory Document

    * @param elementName the local name of the Element

    * @return the Element

    */

   public static Element createElementInSignatureSpace(Document doc,

           String elementName) {

      if (doc == null) {

         throw new RuntimeException("Document is null");

      }

      if ((dsPrefix == null) || (dsPrefix.length() == 0)) {

         return doc.createElementNS(Constants.SignatureSpecNS, elementName);

      }

      if (namePrefix==null) {

          StringBuffer tag=new StringBuffer(dsPrefix);

          tag.append(':');

          tag.append(elementName);

          namePrefix=tag.toString();

          namePrefixes.put(elementName,namePrefix);

      }

      return doc.createElementNS(Constants.SignatureSpecNS, namePrefix);

   }

   /**

    * Returns true if the element is in XML Signature namespace and the local

    * name equals the supplied one.

    *

    * @param element

    * @param localName

    * @return true if the element is in XML Signature namespace and the local name equals the supplied one

    */

   public static boolean elementIsInSignatureSpace(Element element,

           String localName) {

      return ElementProxy.checker.isNamespaceElement(element, localName, Constants.SignatureSpecNS);

   }

   /**

    * Returns true if the element is in XML Encryption namespace and the local

    * name equals the supplied one.

    *

    * @param element

    * @param localName

    * @return true if the element is in XML Encryption namespace and the local name equals the supplied one

    */

   public static boolean elementIsInEncryptionSpace(Element element,

           String localName) {

           return ElementProxy.checker.isNamespaceElement(element, localName, EncryptionConstants.EncryptionSpecNS);

   }

   /**

    * This method returns the owner document of a particular node.

    * This method is necessary because it <I>always</I> returns a

    * {@link Document}. {@link Node#getOwnerDocument} returns <CODE>null</CODE>

    * if the {@link Node} is a {@link Document}.

    *

    * @param node

    * @return the owner document of the node

    */

   public static Document getOwnerDocument(Node node) {

      if (node.getNodeType() == Node.DOCUMENT_NODE) {

         return (Document) node;

      }

         try {

            return node.getOwnerDocument();

         } catch (NullPointerException npe) {

            throw new NullPointerException(I18n.translate("endorsed.jdk1.4.0")

                                           + " Original message was \""

                                           + npe.getMessage() + "\"");

         }

   }

    /**

     * This method returns the first non-null owner document of the Node's in this Set.

     * This method is necessary because it <I>always</I> returns a

     * {@link Document}. {@link Node#getOwnerDocument} returns <CODE>null</CODE>

     * if the {@link Node} is a {@link Document}.

     *

     * @param xpathNodeSet

     * @return the owner document

     */

       NullPointerException npe = null;

           int nodeType =node.getNodeType();

           if (nodeType == Node.DOCUMENT_NODE) {

              return (Document) node;

           }

              try {

                 if (nodeType==Node.ATTRIBUTE_NODE) {

                    return ((Attr)node).getOwnerElement().getOwnerDocument();

                 }

                 return node.getOwnerDocument();

              } catch (NullPointerException e) {

                  npe = e;

              }

       }

       throw new NullPointerException(I18n.translate("endorsed.jdk1.4.0")

                                       + " Original message was \""

                                       + (npe == null ? "" : npe.getMessage()) + "\"");

    }

    /**

     * Method createDSctx

     *

     * @param doc

     * @param prefix

     * @param namespace

     * @return the element.

     */

    public static Element createDSctx(Document doc, String prefix,

                                      String namespace) {

       if ((prefix == null) || (prefix.trim().length() == 0)) {

          throw new IllegalArgumentException("You must supply a prefix");

       }

       Element ctx = doc.createElementNS(null, "namespaceContext");

       ctx.setAttributeNS(Constants.NamespaceSpecNS, "xmlns:" + prefix.trim(),

                          namespace);

       return ctx;

    }

   /**

    * Method addReturnToElement

    *

    * @param e

    */

   public static void addReturnToElement(Element e) {

      if (!ignoreLineBreaks) {

         Document doc = e.getOwnerDocument();

         e.appendChild(doc.createTextNode("\n"));

      }

   }

   public static void addReturnToElement(Document doc, HelperNodeList nl) {

      if (!ignoreLineBreaks) {

         nl.appendChild(doc.createTextNode("\n"));

      }

   }

   public static void addReturnBeforeChild(Element e, Node child) {

      if (!ignoreLineBreaks) {

         Document doc = e.getOwnerDocument();

         e.insertBefore(doc.createTextNode("\n"), child);

      }

   }

   /**

    * Method convertNodelistToSet

    *

    * @param xpathNodeSet

    * @return the set with the nodelist

    */

      if (xpathNodeSet == null) {

      }

      int length = xpathNodeSet.getLength();

      for (int i = 0; i < length; i++) {

         set.add(xpathNodeSet.item(i));

      }

      return set;

   }

   /**

    * This method spreads all namespace attributes in a DOM document to their

    * children. This is needed because the XML Signature XPath transform

    * must evaluate the XPath against all nodes in the input, even against

    * XPath namespace nodes. Through a bug in XalanJ2, the namespace nodes are

    * not fully visible in the Xalan XPath model, so we have to do this by

    * hand in DOM spaces so that the nodes become visible in XPath space.

    *

    * @param doc

    * @see <A HREF="http://nagoya.apache.org/bugzilla/show_bug.cgi?id=2650">Namespace axis resolution is not XPath compliant </A>

    */

   public static void circumventBug2650(Document doc) {

      Element documentElement = doc.getDocumentElement();

      // if the document element has no xmlns definition, we add xmlns=""

      Attr xmlnsAttr =

         documentElement.getAttributeNodeNS(Constants.NamespaceSpecNS, "xmlns");

      if (xmlnsAttr == null) {

         documentElement.setAttributeNS(Constants.NamespaceSpecNS, "xmlns", "");

      }

      XMLUtils.circumventBug2650internal(doc);

   }

   /**

    * This is the work horse for {@link #circumventBug2650}.

    *

    * @param node

    * @see <A HREF="http://nagoya.apache.org/bugzilla/show_bug.cgi?id=2650">Namespace axis resolution is not XPath compliant </A>

    */

   private static void circumventBug2650internal(Node node) {

           Node parent=null;

           Node sibling=null;

           final String namespaceNs=Constants.NamespaceSpecNS;

           do {

         switch (node.getNodeType()) {

         case Node.ELEMENT_NODE :

                 Element element = (Element) node;

             if (!element.hasChildNodes())

                 break;

             if (element.hasAttributes()) {

             NamedNodeMap attributes = element.getAttributes();

             int attributesLength = attributes.getLength();

             for (Node child = element.getFirstChild(); child!=null;

                child=child.getNextSibling()) {

                if (child.getNodeType() != Node.ELEMENT_NODE) {

                        continue;

                }

                Element childElement = (Element) child;

                for (int i = 0; i < attributesLength; i++) {

                        Attr currentAttr = (Attr) attributes.item(i);

                        if (namespaceNs!=currentAttr.getNamespaceURI())

                                continue;

                        if (childElement.hasAttributeNS(namespaceNs,

                                                        currentAttr.getLocalName())) {

                                        continue;

                        }

                        childElement.setAttributeNS(namespaceNs,

                                                currentAttr.getName(),

                                                currentAttr.getNodeValue());

                }

             }

             }

         case Node.ENTITY_REFERENCE_NODE :

         case Node.DOCUMENT_NODE :

                 parent=node;

                 sibling=node.getFirstChild();

             break;

         }

         while ((sibling==null) && (parent!=null)) {

                         sibling=parent.getNextSibling();

                         parent=parent.getParentNode();

                 };

       if (sibling==null) {

                         return;

                 }

         node=sibling;

         sibling=node.getNextSibling();

           } while (true);

   }

   /**

    * @param sibling

    * @param nodeName

    * @param number

    * @return nodes with the constrain

    */

   public static Element selectDsNode(Node sibling, String nodeName, int number) {

        while (sibling!=null) {

                if (ElementProxy.checker.isNamespaceElement(sibling, nodeName, Constants.SignatureSpecNS )) {

                        if (number==0){

                                return (Element)sibling;

                        }

                        number--;