/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You 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.serialize;

import java.io.IOException;

import java.io.OutputStream;

import java.io.StringWriter;

import java.io.UnsupportedEncodingException;

import java.io.Writer;

import java.lang.reflect.Method;

import java.util.ArrayList;

import com.sun.org.apache.xerces.internal.dom.CoreDocumentImpl;

import com.sun.org.apache.xerces.internal.dom.DOMErrorImpl;

import com.sun.org.apache.xerces.internal.dom.DOMLocatorImpl;

import com.sun.org.apache.xerces.internal.dom.DOMMessageFormatter;

import com.sun.org.apache.xerces.internal.dom.DOMNormalizer;

import com.sun.org.apache.xerces.internal.dom.DOMStringListImpl;

import com.sun.org.apache.xerces.internal.impl.Constants;

import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;

import com.sun.org.apache.xerces.internal.util.DOMUtil;

import com.sun.org.apache.xerces.internal.util.NamespaceSupport;

import com.sun.org.apache.xerces.internal.util.SymbolTable;

import com.sun.org.apache.xerces.internal.util.XML11Char;

import com.sun.org.apache.xerces.internal.util.XMLChar;

import org.w3c.dom.Attr;

import org.w3c.dom.Comment;

import org.w3c.dom.DOMConfiguration;

import org.w3c.dom.DOMError;

import org.w3c.dom.DOMErrorHandler;

import org.w3c.dom.DOMException;

import org.w3c.dom.DOMStringList;

import org.w3c.dom.Document;

import org.w3c.dom.DocumentFragment;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.ProcessingInstruction;

import org.w3c.dom.Text;

import org.w3c.dom.ls.LSException;

import org.w3c.dom.ls.LSOutput;

import org.w3c.dom.ls.LSSerializer;

import org.w3c.dom.ls.LSSerializerFilter;

/**

 * EXPERIMENTAL: Implemenatation of DOM Level 3 org.w3c.ls.LSSerializer by

 * delegating serialization calls to <CODE>XMLSerializer</CODE>. LSSerializer

 * provides an API for serializing (writing) a DOM document out in an XML

 * document. The XML data is written to an output stream. During serialization

 * of XML data, namespace fixup is done when possible as defined in DOM Level 3

 * Core, Appendix B.

 *

 * @author Elena Litani, IBM

 * @author Gopal Sharma, Sun Microsystems

 * @author Arun Yadav, Sun Microsystems

 * @author Sunitha Reddy, Sun Microsystems

 */

public class DOMSerializerImpl implements LSSerializer, DOMConfiguration {

    // TODO: When DOM Level 3 goes to REC replace method calls using

    // reflection for: getXmlEncoding, getInputEncoding and getXmlEncoding

    // with regular static calls on the Document object.

    // data

    // serializer

    private XMLSerializer serializer;

    // XML 1.1 serializer

    private XML11Serializer xml11Serializer;

    //Recognized parameters

    private DOMStringList fRecognizedParameters;

    /**

     * REVISIT: Currently we handle 3 different configurations, would be nice

     * just have one configuration that has different recognized parameters

     * depending if it is used in Core/LS.

     */

    protected short features = 0;

    protected final static short NAMESPACES = 0x1 << 0;

    protected final static short WELLFORMED = 0x1 << 1;

    protected final static short ENTITIES = 0x1 << 2;

    protected final static short CDATA = 0x1 << 3;

    protected final static short SPLITCDATA = 0x1 << 4;

    protected final static short COMMENTS = 0x1 << 5;

    protected final static short DISCARDDEFAULT = 0x1 << 6;

    protected final static short INFOSET = 0x1 << 7;

    protected final static short XMLDECL = 0x1 << 8;

    protected final static short NSDECL = 0x1 << 9;

    protected final static short DOM_ELEMENT_CONTENT_WHITESPACE = 0x1 << 10;

    protected final static short PRETTY_PRINT = 0x1 << 11;

    // well-formness checking

    private DOMErrorHandler fErrorHandler = null;

    private final DOMErrorImpl fError = new DOMErrorImpl();

    private final DOMLocatorImpl fLocator = new DOMLocatorImpl();

    /**

     * Constructs a new LSSerializer. The constructor turns on the namespace

     * support in <code>XMLSerializer</code> and initializes the following

     * fields: fNSBinder, fLocalNSBinder, fSymbolTable, fEmptySymbol,

     * fXmlSymbol, fXmlnsSymbol, fNamespaceCounter, fFeatures.

     */

    public DOMSerializerImpl() {

        // set default features

        features |= NAMESPACES;

        features |= ENTITIES;

        features |= COMMENTS;

        features |= CDATA;

        features |= SPLITCDATA;

        features |= WELLFORMED;

        features |= NSDECL;

        features |= DOM_ELEMENT_CONTENT_WHITESPACE;

        features |= DISCARDDEFAULT;

        features |= XMLDECL;

        serializer = new XMLSerializer();

        initSerializer(serializer);

    }

    //

    // LSSerializer methods

    //

    public DOMConfiguration getDomConfig() {

        return this;

    }

    /**

     * DOM L3-EXPERIMENTAL: Setter for boolean and object parameters

     */

    public void setParameter(String name, Object value) throws DOMException {

        if (value instanceof Boolean) {

            boolean state = ((Boolean) value).booleanValue();

            if (name.equalsIgnoreCase(Constants.DOM_INFOSET)) {

                if (state) {

                    features &= ~ENTITIES;

                    features &= ~CDATA;

                    features |= NAMESPACES;

                    features |= NSDECL;

                    features |= WELLFORMED;

                    features |= COMMENTS;

                }

                // false does not have any effect

            } else if (name.equalsIgnoreCase(Constants.DOM_XMLDECL)) {

                features

                        = (short) (state ? features | XMLDECL : features & ~XMLDECL);

            } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)) {

                features

                        = (short) (state

                        ? features | NAMESPACES

                        : features & ~NAMESPACES);

                serializer.fNamespaces = state;

            } else if (name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)) {

                features

                        = (short) (state

                        ? features | SPLITCDATA

                        : features & ~SPLITCDATA);

            } else if (name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)) {

                features

                        = (short) (state

                        ? features | DISCARDDEFAULT

                        : features & ~DISCARDDEFAULT);

            } else if (name.equalsIgnoreCase(Constants.DOM_WELLFORMED)) {

                features

                        = (short) (state

                        ? features | WELLFORMED

                        : features & ~WELLFORMED);

            } else if (name.equalsIgnoreCase(Constants.DOM_ENTITIES)) {

                features

                        = (short) (state

                        ? features | ENTITIES

                        : features & ~ENTITIES);

            } else if (name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)) {

                features

                        = (short) (state

                        ? features | CDATA

                        : features & ~CDATA);

            } else if (name.equalsIgnoreCase(Constants.DOM_COMMENTS)) {

                features

                        = (short) (state

                        ? features | COMMENTS

                        : features & ~COMMENTS);

            } else if (name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)) {

                features

                        = (short) (state

                        ? features | PRETTY_PRINT

                        : features & ~PRETTY_PRINT);

            } else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM)

                    || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)

                    || name.equalsIgnoreCase(Constants.DOM_VALIDATE)

                    || name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION)

                    || name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) {

                //  || name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) {

                // true is not supported

                if (state) {

                    String msg

                            = DOMMessageFormatter.formatMessage(

                                    DOMMessageFormatter.DOM_DOMAIN,

                                    "FEATURE_NOT_SUPPORTED",

                                    new Object[]{name});

                    throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

                }

            } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) {

                //namespace-declaration has effect only if namespaces is true

                features

                        = (short) (state

                        ? features | NSDECL

                        : features & ~NSDECL);

                serializer.fNamespacePrefixes = state;

            } else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE)

                    || name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {

                // false is not supported

                if (!state) {

                    String msg

                            = DOMMessageFormatter.formatMessage(

                                    DOMMessageFormatter.DOM_DOMAIN,

                                    "FEATURE_NOT_SUPPORTED",

                                    new Object[]{name});

                    throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

                }

            } else {

                String msg

                        = DOMMessageFormatter.formatMessage(

                                DOMMessageFormatter.DOM_DOMAIN,

                                "FEATURE_NOT_FOUND",

                                new Object[]{name});

                throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

            }

        } else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)) {

            if (value == null || value instanceof DOMErrorHandler) {

                fErrorHandler = (DOMErrorHandler) value;

            } else {

                String msg

                        = DOMMessageFormatter.formatMessage(

                                DOMMessageFormatter.DOM_DOMAIN,

                                "TYPE_MISMATCH_ERR",

                                new Object[]{name});

                throw new DOMException(DOMException.TYPE_MISMATCH_ERR, msg);

            }

        } else if (name.equalsIgnoreCase(Constants.DOM_RESOURCE_RESOLVER)

                || name.equalsIgnoreCase(Constants.DOM_SCHEMA_LOCATION)

                || name.equalsIgnoreCase(Constants.DOM_SCHEMA_TYPE)

                || name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)

                && value != null) {

            String msg

                    = DOMMessageFormatter.formatMessage(

                            DOMMessageFormatter.DOM_DOMAIN,

                            "FEATURE_NOT_SUPPORTED",

                            new Object[]{name});

            throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

        } else {

            String msg

                    = DOMMessageFormatter.formatMessage(

                            DOMMessageFormatter.DOM_DOMAIN,

                            "FEATURE_NOT_FOUND",

                            new Object[]{name});

            throw new DOMException(DOMException.NOT_FOUND_ERR, msg);

        }

    }

    /**

     * DOM L3-EXPERIMENTAL: Check if parameter can be set

     */

    public boolean canSetParameter(String name, Object state) {

        if (state == null) {

            return true;

        }

        if (state instanceof Boolean) {

            boolean value = ((Boolean) state).booleanValue();

            if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)

                || name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)

                || name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)

                || name.equalsIgnoreCase(Constants.DOM_XMLDECL)

                || name.equalsIgnoreCase(Constants.DOM_WELLFORMED)

                || name.equalsIgnoreCase(Constants.DOM_INFOSET)

                || name.equalsIgnoreCase(Constants.DOM_ENTITIES)

                || name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)

                || name.equalsIgnoreCase(Constants.DOM_COMMENTS)

                || name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)

                || name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) {

                // both values supported

                return true;

            } else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM)

                || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)

                || name.equalsIgnoreCase(Constants.DOM_VALIDATE)

                || name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION)

                || name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) {

                // || name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) {

                // true is not supported

                return !value;

            } else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE)

                || name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {

                // false is not supported

                return value;

            }

        } else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)

                && state == null || state instanceof DOMErrorHandler) {

            return true;

        }

        return false;

    }

    /**

     * DOM Level 3 Core CR - Experimental.

     *

     * The list of the parameters supported by this

     * <code>DOMConfiguration</code> object and for which at least one value can

     * be set by the application. Note that this list can also contain parameter

     * names defined outside this specification.

     */

    public DOMStringList getParameterNames() {

        if (fRecognizedParameters == null) {

            ArrayList parameters = new ArrayList();

            //Add DOM recognized parameters

            //REVISIT: Would have been nice to have a list of

            //recognized parameters.

            parameters.add(Constants.DOM_NAMESPACES);

            parameters.add(Constants.DOM_SPLIT_CDATA);

            parameters.add(Constants.DOM_DISCARD_DEFAULT_CONTENT);

            parameters.add(Constants.DOM_XMLDECL);

            parameters.add(Constants.DOM_CANONICAL_FORM);

            parameters.add(Constants.DOM_VALIDATE_IF_SCHEMA);

            parameters.add(Constants.DOM_VALIDATE);

            parameters.add(Constants.DOM_CHECK_CHAR_NORMALIZATION);

            parameters.add(Constants.DOM_DATATYPE_NORMALIZATION);

            parameters.add(Constants.DOM_FORMAT_PRETTY_PRINT);

            //parameters.add(Constants.DOM_NORMALIZE_CHARACTERS);

            parameters.add(Constants.DOM_WELLFORMED);

            parameters.add(Constants.DOM_INFOSET);

            parameters.add(Constants.DOM_NAMESPACE_DECLARATIONS);

            parameters.add(Constants.DOM_ELEMENT_CONTENT_WHITESPACE);

            parameters.add(Constants.DOM_ENTITIES);

            parameters.add(Constants.DOM_CDATA_SECTIONS);

            parameters.add(Constants.DOM_COMMENTS);

            parameters.add(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS);

            parameters.add(Constants.DOM_ERROR_HANDLER);

            //parameters.add(Constants.DOM_SCHEMA_LOCATION);

            //parameters.add(Constants.DOM_SCHEMA_TYPE);

            //Add recognized xerces features and properties

            fRecognizedParameters = new DOMStringListImpl(parameters);

        }

        return fRecognizedParameters;

    }

    /**

     * DOM L3-EXPERIMENTAL: Getter for boolean and object parameters

     */

    public Object getParameter(String name) throws DOMException {

        if (name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) {

            return null;

        } else if (name.equalsIgnoreCase(Constants.DOM_COMMENTS)) {

            return ((features & COMMENTS) != 0) ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)) {

            return (features & NAMESPACES) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_XMLDECL)) {

            return (features & XMLDECL) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)) {

            return (features & CDATA) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_ENTITIES)) {

            return (features & ENTITIES) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)) {

            return (features & SPLITCDATA) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_WELLFORMED)) {

            return (features & WELLFORMED) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) {

            return (features & NSDECL) != 0 ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE)

                || name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {

            return Boolean.TRUE;

        } else if (name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)) {

            return ((features & DISCARDDEFAULT) != 0) ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)) {

            return ((features & PRETTY_PRINT) != 0) ? Boolean.TRUE : Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_INFOSET)) {

            if ((features & ENTITIES) == 0

                    && (features & CDATA) == 0

                    && (features & NAMESPACES) != 0

                    && (features & NSDECL) != 0

                    && (features & WELLFORMED) != 0

                    && (features & COMMENTS) != 0) {

                return Boolean.TRUE;

            }

            return Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM)

                || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)

                || name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION)

                || name.equalsIgnoreCase(Constants.DOM_VALIDATE)

                || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)

                || name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) {

            return Boolean.FALSE;

        } else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)) {

            return fErrorHandler;

        } else if (name.equalsIgnoreCase(Constants.DOM_RESOURCE_RESOLVER)

                || name.equalsIgnoreCase(Constants.DOM_SCHEMA_LOCATION)

                || name.equalsIgnoreCase(Constants.DOM_SCHEMA_TYPE)) {

            String msg

                    = DOMMessageFormatter.formatMessage(

                            DOMMessageFormatter.DOM_DOMAIN,

                            "FEATURE_NOT_SUPPORTED",

                            new Object[]{name});

            throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);

        } else {

            String msg

                    = DOMMessageFormatter.formatMessage(

                            DOMMessageFormatter.DOM_DOMAIN,

                            "FEATURE_NOT_FOUND",

                            new Object[]{name});

            throw new DOMException(DOMException.NOT_FOUND_ERR, msg);

        }

    }

    /**

     * DOM L3 EXPERIMENTAL: Serialize the specified node as described above in

     * the description of <code>LSSerializer</code>. The result of serializing

     * the node is returned as a string. Writing a Document or Entity node

     * produces a serialized form that is well formed XML. Writing other node

     * types produces a fragment of text in a form that is not fully defined by

     * this document, but that should be useful to a human for debugging or

     * diagnostic purposes.

     *

     * @param wnode The node to be written.

     * @return Returns the serialized data

     * @exception DOMException DOMSTRING_SIZE_ERR: The resulting string is too

     * long to fit in a <code>DOMString</code>.

     * @exception LSException SERIALIZE_ERR: Unable to serialize the node. DOM

     * applications should attach a <code>DOMErrorHandler</code> using the

     * parameter &quot;<i>error-handler</i>&quot; to get details on error.

     */

    public String writeToString(Node wnode) throws DOMException, LSException {

        // determine which serializer to use:

        XMLSerializer ser = null;

        String ver = _getXmlVersion(wnode);

        if (ver != null && ver.equals("1.1")) {

            if (xml11Serializer == null) {

                xml11Serializer = new XML11Serializer();

                initSerializer(xml11Serializer);

            }

            // copy setting from "main" serializer to XML 1.1 serializer

            copySettings(serializer, xml11Serializer);

            ser = xml11Serializer;

        } else {

            ser = serializer;

        }

        StringWriter destination = new StringWriter();

        try {

            prepareForSerialization(ser, wnode);

            ser._format.setEncoding("UTF-16");

            ser.setOutputCharStream(destination);

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

                ser.serialize((Document) wnode);

            } else if (wnode.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) {

                ser.serialize((DocumentFragment) wnode);

            } else if (wnode.getNodeType() == Node.ELEMENT_NODE) {

                ser.serialize((Element) wnode);

            } else if (wnode.getNodeType() == Node.TEXT_NODE

                    || wnode.getNodeType() == Node.COMMENT_NODE

                    || wnode.getNodeType() == Node.ENTITY_REFERENCE_NODE

                    || wnode.getNodeType() == Node.CDATA_SECTION_NODE

                    || wnode.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {

                ser.serialize(wnode);

            } else {

                String msg = DOMMessageFormatter.formatMessage(

                        DOMMessageFormatter.SERIALIZER_DOMAIN,

                        "unable-to-serialize-node", null);

                if (ser.fDOMErrorHandler != null) {

                    DOMErrorImpl error = new DOMErrorImpl();

                    error.fType = "unable-to-serialize-node";

                    error.fMessage = msg;

                    error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;

                    ser.fDOMErrorHandler.handleError(error);

                }

                throw new LSException(LSException.SERIALIZE_ERR, msg);

            }

        } catch (LSException lse) {

            // Rethrow LSException.

            throw lse;

        } catch (RuntimeException e) {

            if (e == DOMNormalizer.abort) {

                // stopped at user request

                return null;