/*

 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.messaging.saaj.soap.impl;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.*;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.xml.namespace.QName;

import javax.xml.soap.*;

import org.w3c.dom.*;

import org.w3c.dom.Node;

import com.sun.xml.internal.messaging.saaj.SOAPExceptionImpl;

import com.sun.xml.internal.messaging.saaj.soap.SOAPDocument;

import com.sun.xml.internal.messaging.saaj.soap.SOAPDocumentImpl;

import com.sun.xml.internal.messaging.saaj.soap.name.NameImpl;

import com.sun.xml.internal.messaging.saaj.util.*;

public class ElementImpl

    extends com.sun.org.apache.xerces.internal.dom.ElementNSImpl

    implements SOAPElement, SOAPBodyElement {

    public static final String DSIG_NS = "http://www.w3.org/2000/09/xmldsig#".intern();

    public static final String XENC_NS = "http://www.w3.org/2001/04/xmlenc#".intern();

    public static final String WSU_NS = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd".intern();

    private transient AttributeManager encodingStyleAttribute = new AttributeManager();

    protected QName elementQName;

    protected static final Logger log =

        Logger.getLogger(LogDomainConstants.SOAP_IMPL_DOMAIN,

                         "com.sun.xml.internal.messaging.saaj.soap.impl.LocalStrings");

    /**

     * XML Information Set REC

     * all namespace attributes (including those named xmlns,

     * whose [prefix] property has no value) have a namespace URI of http://www.w3.org/2000/xmlns/

     */

    public final static String XMLNS_URI = "http://www.w3.org/2000/xmlns/".intern();

    /**

     * The XML Namespace ("http://www.w3.org/XML/1998/namespace"). This is

     * the Namespace URI that is automatically mapped to the "xml" prefix.

     */

    public final static String XML_URI = "http://www.w3.org/XML/1998/namespace".intern();

    public ElementImpl(SOAPDocumentImpl ownerDoc, Name name) {

        super(

            ownerDoc,

            name.getURI(),

            name.getQualifiedName(),

            name.getLocalName());

        elementQName = NameImpl.convertToQName(name);

    }

    public ElementImpl(SOAPDocumentImpl ownerDoc, QName name) {

        super(

            ownerDoc,

            name.getNamespaceURI(),

            getQualifiedName(name),

            name.getLocalPart());

        elementQName = name;

    }

    public ElementImpl(

        SOAPDocumentImpl ownerDoc,

        String uri,

        String qualifiedName) {

        super(ownerDoc, uri, qualifiedName);

        elementQName =

            new QName(uri, getLocalPart(qualifiedName), getPrefix(qualifiedName));

    }

    public void ensureNamespaceIsDeclared(String prefix, String uri) {

        String alreadyDeclaredUri = getNamespaceURI(prefix);

        if (alreadyDeclaredUri == null || !alreadyDeclaredUri.equals(uri)) {

            try {

                addNamespaceDeclaration(prefix, uri);

            } catch (SOAPException e) { /*ignore*/

            }

        }

    }

    public Document getOwnerDocument() {

        Document doc = super.getOwnerDocument();

        if (doc instanceof SOAPDocument)

            return ((SOAPDocument) doc).getDocument();

        else

            return doc;

    }

    public SOAPElement addChildElement(Name name) throws SOAPException {

        return  addElement(name);

    }

    public SOAPElement addChildElement(QName qname) throws SOAPException {

        return  addElement(qname);

    }

    public SOAPElement addChildElement(String localName) throws SOAPException {

        return (SOAPElement) addChildElement(

            NameImpl.createFromUnqualifiedName(localName));

    }

    public SOAPElement addChildElement(String localName, String prefix)

        throws SOAPException {

        String uri = getNamespaceURI(prefix);

        if (uri == null) {

            log.log(

                Level.SEVERE,

                "SAAJ0101.impl.parent.of.body.elem.mustbe.body",

                new String[] { prefix });

            throw new SOAPExceptionImpl(

                "Unable to locate namespace for prefix " + prefix);

        }

        return addChildElement(localName, prefix, uri);

    }

    public String getNamespaceURI(String prefix) {

        if ("xmlns".equals(prefix)) {

            return XMLNS_URI;

        }

        if("xml".equals(prefix)) {

            return XML_URI;

        }

        if ("".equals(prefix)) {

            org.w3c.dom.Node currentAncestor = this;

            while (currentAncestor != null &&

                   !(currentAncestor instanceof Document)) {

                if (currentAncestor instanceof ElementImpl) {

                    QName name = ((ElementImpl) currentAncestor).getElementQName();

                    /*

                    if (prefix.equals(name.getPrefix())) {

                        String uri = name.getNamespaceURI();

                        if ("".equals(uri)) {

                            return null;

                        }

                        else {

                            return uri;

                        }

                    }*/

                    if (((Element) currentAncestor).hasAttributeNS(

                            XMLNS_URI, "xmlns")) {

                        String uri =

                            ((Element) currentAncestor).getAttributeNS(

                                XMLNS_URI, "xmlns");

                        if ("".equals(uri))

                            return null;

                        else {

                            return uri;

                        }

                    }

                }

                currentAncestor = currentAncestor.getParentNode();

            }

        } else if (prefix != null) {

            // Find if there's an ancester whose name contains this prefix

            org.w3c.dom.Node currentAncestor = this;

//            String uri = currentAncestor.lookupNamespaceURI(prefix);

//            return uri;

            while (currentAncestor != null &&

                   !(currentAncestor instanceof Document)) {

               /* if (prefix.equals(currentAncestor.getPrefix())) {

                    String uri = currentAncestor.getNamespaceURI();

                    // this is because the javadoc says getNamespaceURI() is not a computed value

                    // and URI for a non-empty prefix cannot be null

                    if (uri != null)

                        return uri;

                }*/

                //String uri = currentAncestor.lookupNamespaceURI(prefix);

                //if (uri != null) {

                //    return uri;

                //}

                if (((Element) currentAncestor).hasAttributeNS(

                        XMLNS_URI, prefix)) {

                    return ((Element) currentAncestor).getAttributeNS(

                               XMLNS_URI, prefix);

                }

                currentAncestor = currentAncestor.getParentNode();

            }

        }

        return null;

    }

    public SOAPElement setElementQName(QName newName) throws SOAPException {

        ElementImpl copy =

            new ElementImpl((SOAPDocumentImpl) getOwnerDocument(), newName);

        return replaceElementWithSOAPElement(this,copy);

    }

    public QName createQName(String localName, String prefix)

        throws SOAPException {

        String uri = getNamespaceURI(prefix);

        if (uri == null) {

            log.log(Level.SEVERE, "SAAJ0102.impl.cannot.locate.ns",

                    new Object[] {prefix});

            throw new SOAPException("Unable to locate namespace for prefix "

                                    + prefix);

        }

        return new QName(uri, localName, prefix);

    }

    public String getNamespacePrefix(String uri) {

        NamespaceContextIterator eachNamespace = getNamespaceContextNodes();

        while (eachNamespace.hasNext()) {

            org.w3c.dom.Attr namespaceDecl = eachNamespace.nextNamespaceAttr();

            if (namespaceDecl.getNodeValue().equals(uri)) {

                String candidatePrefix = namespaceDecl.getLocalName();

                if ("xmlns".equals(candidatePrefix))

                    return "";

                else

                    return candidatePrefix;

            }

        }

        // Find if any of the ancestors' name has this uri

        org.w3c.dom.Node currentAncestor = this;

        while (currentAncestor != null &&

               !(currentAncestor instanceof Document)) {

            if (uri.equals(currentAncestor.getNamespaceURI()))

                return currentAncestor.getPrefix();

            currentAncestor = currentAncestor.getParentNode();

        }

        return null;

    }

    protected org.w3c.dom.Attr getNamespaceAttr(String prefix) {

        NamespaceContextIterator eachNamespace = getNamespaceContextNodes();

        if (!"".equals(prefix))

            prefix = ":"+prefix;

        while (eachNamespace.hasNext()) {

            org.w3c.dom.Attr namespaceDecl = eachNamespace.nextNamespaceAttr();

            if (!"".equals(prefix)) {

                if (namespaceDecl.getNodeName().endsWith(prefix))

                    return namespaceDecl;

            } else {

                if (namespaceDecl.getNodeName().equals("xmlns"))

                    return namespaceDecl;

            }

        }

        return null;

    }

    public NamespaceContextIterator getNamespaceContextNodes() {

        return getNamespaceContextNodes(true);

    }

    public NamespaceContextIterator getNamespaceContextNodes(boolean traverseStack) {

        return new NamespaceContextIterator(this, traverseStack);

    }

    public SOAPElement addChildElement(

        String localName,

        String prefix,

        String uri)

        throws SOAPException {

        SOAPElement newElement = createElement(NameImpl.create(localName, prefix, uri));

        addNode(newElement);

        return convertToSoapElement(newElement);

    }

    public SOAPElement addChildElement(SOAPElement element)

        throws SOAPException {

        // check if Element falls in SOAP 1.1 or 1.2 namespace.

        String elementURI = element.getElementName().getURI();

        String localName = element.getLocalName();

        if ((SOAPConstants.URI_NS_SOAP_ENVELOPE).equals(elementURI)

            || (SOAPConstants.URI_NS_SOAP_1_2_ENVELOPE).equals(elementURI)) {

            if ("Envelope".equalsIgnoreCase(localName) ||

                "Header".equalsIgnoreCase(localName) || "Body".equalsIgnoreCase(localName)) {

                log.severe("SAAJ0103.impl.cannot.add.fragements");

                throw new SOAPExceptionImpl(

                    "Cannot add fragments which contain elements "

                        + "which are in the SOAP namespace");

            }

            if ("Fault".equalsIgnoreCase(localName) && !"Body".equalsIgnoreCase(this.getLocalName())) {

                log.severe("SAAJ0154.impl.adding.fault.to.nonbody");

                throw new SOAPExceptionImpl("Cannot add a SOAPFault as a child of " + this.getLocalName());

            }

            if ("Detail".equalsIgnoreCase(localName) && !"Fault".equalsIgnoreCase(this.getLocalName())) {

                log.severe("SAAJ0155.impl.adding.detail.nonfault");

                throw new SOAPExceptionImpl("Cannot add a Detail as a child of " + this.getLocalName());

            }

            if ("Fault".equalsIgnoreCase(localName)) {

               // if body is not empty throw an exception

               if (!elementURI.equals(this.getElementName().getURI())) {

                   log.severe("SAAJ0158.impl.version.mismatch.fault");

                   throw new SOAPExceptionImpl("SOAP Version mismatch encountered when trying to add SOAPFault to SOAPBody");

               }

               Iterator it = this.getChildElements();

               if (it.hasNext()) {

                   log.severe("SAAJ0156.impl.adding.fault.error");

                   throw new SOAPExceptionImpl("Cannot add SOAPFault as a child of a non-Empty SOAPBody");

               }

            }

        }

        // preserve the encodingStyle attr as it may get lost in the import

        String encodingStyle = element.getEncodingStyle();

        ElementImpl importedElement = (ElementImpl) importElement(element);

        addNode(importedElement);

        if (encodingStyle != null)

            importedElement.setEncodingStyle(encodingStyle);

        return convertToSoapElement(importedElement);

    }

    protected Element importElement(Element element) {

        Document document = getOwnerDocument();

        Document oldDocument = element.getOwnerDocument();

        if (!oldDocument.equals(document)) {

            return (Element) document.importNode(element, true);

        } else {

            return element;

        }

    }

    protected SOAPElement addElement(Name name) throws SOAPException {

        SOAPElement newElement = createElement(name);

        addNode(newElement);

        return circumventBug5034339(newElement);

    }

    protected SOAPElement addElement(QName name) throws SOAPException {

        SOAPElement newElement = createElement(name);

        addNode(newElement);

        return circumventBug5034339(newElement);

    }

    protected SOAPElement createElement(Name name) {

        if (isNamespaceQualified(name)) {

            return (SOAPElement)

                getOwnerDocument().createElementNS(

                                       name.getURI(),

                                       name.getQualifiedName());

        } else {

            return (SOAPElement)

                getOwnerDocument().createElement(name.getQualifiedName());

        }

    }

    protected SOAPElement createElement(QName name) {

        if (isNamespaceQualified(name)) {

            return (SOAPElement)

                getOwnerDocument().createElementNS(

                                       name.getNamespaceURI(),

                                       getQualifiedName(name));

        } else {

            return (SOAPElement)

                getOwnerDocument().createElement(getQualifiedName(name));

        }

    }

    protected void addNode(org.w3c.dom.Node newElement) throws SOAPException {

        insertBefore(newElement, null);

        if (getOwnerDocument() instanceof DocumentFragment)

            return;

        if (newElement instanceof ElementImpl) {

            ElementImpl element = (ElementImpl) newElement;

            QName elementName = element.getElementQName();

            if (!"".equals(elementName.getNamespaceURI())) {

                element.ensureNamespaceIsDeclared(

                    elementName.getPrefix(), elementName.getNamespaceURI());

            }

        }

    }

    Element getFirstChildElement() {

        Node child = getFirstChild();

        while (child != null) {

            if (child instanceof Element) {

                return ((Element) child);

            }

            child = child.getNextSibling();

        }

        return null;

    }

    protected SOAPElement findChild(NameImpl name) {

        Node eachChild = getFirstChild();

        while (eachChild != null) {

            if (eachChild instanceof SOAPElement) {

                SOAPElement eachChildSoap = (SOAPElement) eachChild;

                if (eachChildSoap.getElementName().equals(name)) {

                    return eachChildSoap;

                }

            }

            eachChild = eachChild.getNextSibling();

        }

        return null;

    }

    protected SOAPElement findAndConvertChildElement(NameImpl name) {

        Iterator eachChild = getChildElementNodes();

        while (eachChild.hasNext()) {

            SOAPElement child = (SOAPElement) eachChild.next();

            if (child.getElementName().equals(name)) {

                return child;

            }

        }

        return null;

    }

    public SOAPElement addTextNode(String text) throws SOAPException {

        if (text.startsWith(CDATAImpl.cdataUC)

            || text.startsWith(CDATAImpl.cdataLC))

            return addCDATA(

                text.substring(CDATAImpl.cdataUC.length(), text.length() - 3));

        return addText(text);

    }

    protected SOAPElement addCDATA(String text) throws SOAPException {

        org.w3c.dom.Text cdata =

            (org.w3c.dom.Text) getOwnerDocument().createCDATASection(text);

        addNode(cdata);

        return this;

    }

    protected SOAPElement addText(String text) throws SOAPException {

        org.w3c.dom.Text textNode =

            (org.w3c.dom.Text) getOwnerDocument().createTextNode(text);

        addNode(textNode);

        return this;

    }

    public SOAPElement addAttribute(Name name, String value)

        throws SOAPException {

        addAttributeBare(name, value);

        if (!"".equals(name.getURI())) {

            ensureNamespaceIsDeclared(name.getPrefix(), name.getURI());

        }

        return this;

    }

    public SOAPElement addAttribute(QName qname, String value)

        throws SOAPException {

        addAttributeBare(qname, value);

        if (!"".equals(qname.getNamespaceURI())) {

            ensureNamespaceIsDeclared(qname.getPrefix(), qname.getNamespaceURI());

        }

        return this;

    }

    private void addAttributeBare(Name name, String value) {

        addAttributeBare(

            name.getURI(),

            name.getPrefix(),

            name.getQualifiedName(),

            value);

    }

    private void addAttributeBare(QName name, String value) {

        addAttributeBare(

            name.getNamespaceURI(),

            name.getPrefix(),

            getQualifiedName(name),

            value);

    }

    private void addAttributeBare(

        String uri,

        String prefix,

        String qualifiedName,

        String value) {

        uri = uri.length() == 0 ? null : uri;

        if (qualifiedName.equals("xmlns")) {