/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.tax.dom;

import java.util.Iterator;
import org.w3c.dom.*;
import org.netbeans.tax.*;
import org.netbeans.tax.TreeObjectList;

/**
 *
 * @author  Petr Kuzel
 */
class DocumentImpl extends NodeImpl implements Document{
    
    private final TreeDocumentRoot peer;
    
    /** Creates a new instance of AttrImpl */
    public DocumentImpl(TreeDocumentRoot peer) {
        this.peer = peer;
    }
    
    /** Creates an Attr of the given name. Note that the
     * Attr instance can then be set on an Element
     * using the setAttributeNode method.
     * 
To create an attribute with a qualified name and namespace URI, use
     * the createAttributeNS method.
     * @param name The name of the attribute.
     * @return A new Attr object with the nodeName
     *   attribute set to name, and localName,
     *   prefix, and namespaceURI set to
     *   null. The value of the attribute is the empty string.
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
     *   illegal character.
     *
     */
    public Attr createAttribute(String name) throws DOMException {
        throw new ROException();
    }
    
    /** Creates an attribute of the given qualified name and namespace URI.
     * @param namespaceURI The namespace URI of the attribute to create.
     * @param qualifiedName The qualified name of the attribute to
     *   instantiate.
     * @return A new Attr object with the following attributes:
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 

     *   Attribute
Value
Node.nodeName
qualifiedName

     *   Node.namespaceURI
namespaceURI

     *   Node.prefix
prefix, extracted from
     *   qualifiedName, or null if there is no
     *   prefix
Node.localName
local name, extracted from
     *   qualifiedName
Attr.name

     *   qualifiedName
Node.nodeValue
the empty
     *   string
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified qualified name
     *   contains an illegal character, per the XML 1.0 specification .
     *   
NAMESPACE_ERR: Raised if the qualifiedName is
     *   malformed per the Namespaces in XML specification, if the
     *   qualifiedName has a prefix and the
     *   namespaceURI is null, if the
     *   qualifiedName has a prefix that is "xml" and the
     *   namespaceURI is different from "
     *   http://www.w3.org/XML/1998/namespace", or if the
     *   qualifiedName, or its prefix, is "xmlns" and the
     *   namespaceURI is different from "
     *   http://www.w3.org/2000/xmlns/".
     *   
NOT_SUPPORTED_ERR: Always thrown if the current document does not
     *   support the "XML" feature, since namespaces were
     *   defined by XML.
     * @since DOM Level 2
     *
     */
    public Attr createAttributeNS(String namespaceURI, String qualifiedName) throws DOMException {
        throw new ROException();
    }
    
    /** Creates a CDATASection node whose value is the specified
     * string.
     * @param data The data for the CDATASection contents.
     * @return The new CDATASection object.
     * @exception DOMException
     *   NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
     *
     */
    public CDATASection createCDATASection(String data) throws DOMException {
        throw new ROException();
    }
    
    /** Creates a Comment node given the specified string.
     * @param data The data for the node.
     * @return The new Comment object.
     *
     */
    public Comment createComment(String data) {
        throw new ROException();
    }
    
    /** Creates an empty DocumentFragment object.
     * @return A new DocumentFragment.
     *
     */
    public DocumentFragment createDocumentFragment() {
        throw new ROException();
    }
    
    /** Creates an element of the type specified. Note that the instance
     * returned implements the Element interface, so attributes
     * can be specified directly on the returned object.
     * 
In addition, if there are known attributes with default values,
     * Attr nodes representing them are automatically created
     * and attached to the element.
     * 
To create an element with a qualified name and namespace URI, use
     * the createElementNS method.
     * @param tagName The name of the element type to instantiate. For XML,
     *   this is case-sensitive. For HTML, the tagName
     *   parameter may be provided in any case, but it must be mapped to the
     *   canonical uppercase form by the DOM implementation.
     * @return A new Element object with the
     *   nodeName attribute set to tagName, and
     *   localName, prefix, and
     *   namespaceURI set to null.
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
     *   illegal character.
     *
     */
    public Element createElement(String tagName) throws DOMException {
        throw new ROException();
    }
    
    /** Creates an element of the given qualified name and namespace URI.
     * @param namespaceURI The namespace URI of the element to create.
     * @param qualifiedName The qualified name of the element type to
     *   instantiate.
     * @return A new Element object with the following
     *   attributes:
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Attribute
Value
Node.nodeName

     *   qualifiedName
Node.namespaceURI

     *   namespaceURI
Node.prefix
prefix, extracted
     *   from qualifiedName, or null if there is
     *   no prefix
Node.localName
local name, extracted from
     *   qualifiedName
Element.tagName

     *   qualifiedName
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified qualified name
     *   contains an illegal character, per the XML 1.0 specification .
     *   
NAMESPACE_ERR: Raised if the qualifiedName is
     *   malformed per the Namespaces in XML specification, if the
     *   qualifiedName has a prefix and the
     *   namespaceURI is null, or if the
     *   qualifiedName has a prefix that is "xml" and the
     *   namespaceURI is different from "
     *   http://www.w3.org/XML/1998/namespace" .
     *   
NOT_SUPPORTED_ERR: Always thrown if the current document does not
     *   support the "XML" feature, since namespaces were
     *   defined by XML.
     * @since DOM Level 2
     *
     */
    public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException {
        throw new ROException();
    }
    
    /** Creates an EntityReference object. In addition, if the
     * referenced entity is known, the child list of the
     * EntityReference node is made the same as that of the
     * corresponding Entity node.If any descendant of the
     * Entity node has an unbound namespace prefix, the
     * corresponding descendant of the created EntityReference
     * node is also unbound; (its namespaceURI is
     * null). The DOM Level 2 does not support any mechanism to
     * resolve namespace prefixes.
     * @param name The name of the entity to reference.
     * @return The new EntityReference object.
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified name contains an
     *   illegal character.
     *   
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
     *
     */
    public EntityReference createEntityReference(String name) throws DOMException {
        throw new ROException();
    }
    
    /** Creates a ProcessingInstruction node given the specified
     * name and data strings.
     * @param target The target part of the processing instruction.
     * @param data The data for the node.
     * @return The new ProcessingInstruction object.
     * @exception DOMException
     *   INVALID_CHARACTER_ERR: Raised if the specified target contains an
     *   illegal character.
     *   
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
     *
     */
    public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException {
        throw new ROException();
    }
    
    /** Creates a Text node given the specified string.
     * @param data The data for the node.
     * @return The new Text object.
     *
     */
    public Text createTextNode(String data) {
        throw new ROException();
    }
    
    /** The Document Type Declaration (see DocumentType)
     * associated with this document. For HTML documents as well as XML
     * documents without a document type declaration this returns
     * null. The DOM Level 2 does not support editing the
     * Document Type Declaration. docType cannot be altered in
     * any way, including through the use of methods inherited from the
     * Node interface, such as insertNode or
     * removeNode.
     *
     */
    public DocumentType getDoctype() {
        return null; //!!!
    }
    
    /** This is a convenience attribute that allows direct access to the child
     * node that is the root element of the document. For HTML documents,
     * this is the element with the tagName "HTML".
     *
     */
    public Element getDocumentElement() {
        Iterator it = peer.getChildNodes().iterator();
        while (it.hasNext()) {            
            Object next = it.next();
            if (next instanceof TreeElement) {
                return Wrapper.wrap((TreeElement)next);
            }
        }
        return null;
    }
    
    /** Returns the Element whose ID is given by
     * elementId. If no such element exists, returns
     * null. Behavior is not defined if more than one element
     * has this ID. The DOM implementation must have
     * information that says which attributes are of type ID. Attributes
     * with the name "ID" are not of type ID unless so defined.
     * Implementations that do not know whether attributes are of type ID or
     * not are expected to return null.
     * @param elementId The unique id value for an element.
     * @return The matching element.
     * @since DOM Level 2
     *
     */
    public Element getElementById(String elementId) {
        throw new UOException();
    }
    
    /** Returns a NodeList of all the Elements with a
     * given tag name in the order in which they are encountered in a
     * preorder traversal of the Document tree.
     * @param tagname The name of the tag to match on. The special value "*"
     *   matches all tags.
     * @return A new NodeList object containing all the matched
     *   Elements.
     *
     */
    public NodeList getElementsByTagName(String tagname) {
        throw new UOException(); //???
    }
    
    /** Returns a NodeList of all the Elements with a
     * given local name and namespace URI in the order in which they are
     * encountered in a preorder traversal of the Document tree.
     * @param namespaceURI The namespace URI of the elements to match on. The
     *   special value "*" matches all namespaces.
     * @param localName The local name of the elements to match on. The
     *   special value "*" matches all local names.
     * @return A new NodeList object containing all the matched
     *   Elements.
     * @since DOM Level 2
     *
     */
    public NodeList getElementsByTagNameNS(String namespaceURI, String localName) {
        throw new UOException();
    }
    
    /** The DOMImplementation object that handles this document. A
     * DOM application may use objects from multiple implementations.
     *
     */
    public DOMImplementation getImplementation() {
        return new DOMImplementationImpl();
    }
    
    /** The name of this node, depending on its type; see the table above.
     *
     */
    public String getNodeName() {
        return "#document";
    }
    
    /** A code representing the type of the underlying object, as defined above.
     *
     */
    public short getNodeType() {
        return Node.DOCUMENT_NODE;
    }
    
    /** The value of this node, depending on its type; see the table above.
     * When it is defined to be null, setting it has no effect.
     * @exception DOMException
     *   NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
     * @exception DOMException
     *   DOMSTRING_SIZE_ERR: Raised when it would return more characters than
     *   fit in a DOMString variable on the implementation
     *   platform.
     *
     */
    public String getNodeValue() throws DOMException {
        return null;
    }
    
    /** The parent of this node. All nodes, except Attr,
     * Document, DocumentFragment,
     * Entity, and Notation may have a parent.
     * However, if a node has just been created and not yet added to the
     * tree, or if it has been removed from the tree, this is
     * null.
     *
     */
    public Node getParentNode() {
        return null;
    }
    
    /** Imports a node from another document to this document. The returned
     * node has no parent; (parentNode is null).
     * The source node is not altered or removed from the original document;
     * this method creates a new copy of the source node.
     * 
For all nodes, importing a node creates a node object owned by the
     * importing document, with attribute values identical to the source
     * node's nodeName and nodeType, plus the
     * attributes related to namespaces (prefix,
     * localName, and namespaceURI). As in the
     * cloneNode operation on a Node, the source
     * node is not altered.
     * 
Additional information is copied as appropriate to the
     * nodeType, attempting to mirror the behavior expected if
     * a fragment of XML or HTML source was copied from one document to
     * another, recognizing that the two documents may have different DTDs
     * in the XML case. The following list describes the specifics for each
     * type of node.
     * 

     * 
ATTRIBUTE_NODE
     * 
The ownerElement attribute
     * is set to null and the specified flag is
     * set to true on the generated Attr. The
     * descendants of the source Attr are recursively imported
     * and the resulting nodes reassembled to form the corresponding subtree.
     * Note that the deep parameter has no effect on
     * Attr nodes; they always carry their children with them
     * when imported.
     * 
DOCUMENT_FRAGMENT_NODE
     * 
If the deep option
     * was set to true, the descendants of the source element
     * are recursively imported and the resulting nodes reassembled to form
     * the corresponding subtree. Otherwise, this simply generates an empty
     * DocumentFragment.
     * 
DOCUMENT_NODE
     * 
Document
     * nodes cannot be imported.
     * 
DOCUMENT_TYPE_NODE
     * 
DocumentType
     * nodes cannot be imported.
     * 
ELEMENT_NODE
     * 
Specified attribute nodes of the
     * source element are imported, and the generated Attr
     * nodes are attached to the generated Element. Default
     * attributes are not copied, though if the document being imported into
     * defines default attributes for this element name, those are assigned.
     * If the importNode deep parameter was set to
     * true, the descendants of the source element are
     * recursively imported and the resulting nodes reassembled to form the
     * corresponding subtree.
     * 
ENTITY_NODE
     * 
Entity nodes can be
     * imported, however in the current release of the DOM the
     * DocumentType is readonly. Ability to add these imported
     * nodes to a DocumentType will be considered for addition
     * to a future release of the DOM.On import, the publicId,
     * systemId, and notationName attributes are
     * copied. If a deep import is requested, the descendants
     * of the the source Entity are recursively imported and
     * the resulting nodes reassembled to form the corresponding subtree.
     * 

     * ENTITY_REFERENCE_NODE
     * 
Only the EntityReference itself is
     * copied, even if a deep import is requested, since the
     * source and destination documents might have defined the entity
     * differently. If the document being imported into provides a
     * definition for this entity name, its value is assigned.
     * 
NOTATION_NODE
     * 

     * Notation nodes can be imported, however in the current
     * release of the DOM the DocumentType is readonly. Ability
     * to add these imported nodes to a DocumentType will be
     * considered for addition to a future release of the DOM.On import, the
     * publicId and systemId attributes are copied.
     * Note that the deep parameter has no effect on
     * Notation nodes since they never have any children.
     * 

     * PROCESSING_INSTRUCTION_NODE
     * 
The imported node copies its
     * target and data values from those of the
     * source node.
     * 
TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE
     * 
These three
     * types of nodes inheriting from CharacterData copy their
     * data and length attributes from those of
     * the source node.
     * 
     * @param importedNode The node to import.
     * @param deep If true, recursively import the subtree under
     *   the specified node; if false, import only the node
     *   itself, as explained above. This has no effect on Attr
     *   , EntityReference, and Notation nodes.
     * @return The imported node that belongs to this Document.
     * @exception DOMException
     *   NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
     *   supported.
     * @since DOM Level 2
     *
     */
    public Node importNode(Node importedNode, boolean deep) throws DOMException {
        throw new UOException();
    }
    
    /** The first child of this node. If there is no such node, this returns
     * null.
     *
     */
    public Node getFirstChild() {
        return getDocumentElement();
    }

    /** The last child of this node. If there is no such node, this returns
     * null.
     *
     */
    public Node getLastChild() {
        return getDocumentElement();
    }

    /** Returns whether this node has any children.
     * @return true if this node has any children,
     *   false otherwise.
     *
     */
    public boolean hasChildNodes() {
        return getDocumentElement() != null;
    }
    
    /** A NodeList that contains all children of this node. If
     * there are no children, this is a NodeList containing no
     * nodes.
     *
     */
    public NodeList getChildNodes() {
        return Wrapper.wrap(peer.getChildNodes());
    }
    
    //
    // Dom Level 3 methods:
    //
    
    public Node adoptNode (Node a) {
        throw new UOException ();
    }
    public String getDocumentURI () {
        throw new UOException ();
    }
    public DOMConfiguration getDomConfig() {
        throw new UOException ();
    }
    public String getInputEncoding() {
        throw new UOException ();
    }
    public boolean getStrictErrorChecking() {
        throw new UOException ();
    }
    public String getXmlEncoding () {
        throw new UOException ();
    }
    public boolean getXmlStandalone() {
        throw new UOException ();
    }
    public String getXmlVersion()  {
        throw new UOException ();
    }
    public void normalizeDocument() {
        throw new UOException ();
    }
    public Node renameNode(Node a, String nb, String c) {
        throw new UOException ();
    }
    public void setDocumentURI(String a) {
        throw new UOException ();
    }
    public void setStrictErrorChecking(boolean a) {
        throw new UOException ();
    }
    public void setXmlStandalone(boolean a) {
        throw new UOException ();
    }
    public void setXmlVersion(String a) {
        throw new UOException ();
    }
}