/*

 * Copyright (c) 1997, 2013, 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.bind.v2.runtime;

import java.io.IOException;

import java.lang.reflect.Method;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import javax.activation.MimeType;

import javax.xml.bind.DatatypeConverter;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Marshaller;

import javax.xml.bind.ValidationEvent;

import javax.xml.bind.ValidationEventHandler;

import javax.xml.bind.ValidationEventLocator;

import javax.xml.bind.annotation.DomHandler;

import javax.xml.bind.annotation.XmlNs;

import javax.xml.bind.attachment.AttachmentMarshaller;

import javax.xml.bind.helpers.NotIdentifiableEventImpl;

import javax.xml.bind.helpers.ValidationEventImpl;

import javax.xml.bind.helpers.ValidationEventLocatorImpl;

import javax.xml.namespace.QName;

import javax.xml.stream.XMLStreamException;

import javax.xml.transform.Source;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerException;

import javax.xml.transform.sax.SAXResult;

import com.sun.istack.internal.SAXException2;

import com.sun.xml.internal.bind.CycleRecoverable;

import com.sun.xml.internal.bind.api.AccessorException;

import com.sun.xml.internal.bind.marshaller.NamespacePrefixMapper;

import com.sun.xml.internal.bind.util.ValidationEventLocatorExImpl;

import com.sun.xml.internal.bind.v2.WellKnownNamespace;

import com.sun.xml.internal.bind.v2.model.runtime.RuntimeBuiltinLeafInfo;

import com.sun.xml.internal.bind.v2.runtime.output.MTOMXmlOutput;

import com.sun.xml.internal.bind.v2.runtime.output.NamespaceContextImpl;

import com.sun.xml.internal.bind.v2.runtime.output.Pcdata;

import com.sun.xml.internal.bind.v2.runtime.output.XmlOutput;

import com.sun.xml.internal.bind.v2.runtime.property.Property;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.IntData;

import com.sun.xml.internal.bind.v2.util.CollisionCheckStack;

import org.xml.sax.SAXException;

/**

 * Receives XML serialization event and writes to {@link XmlOutput}.

 *

 * <p>

 * This object coordinates the overall marshalling efforts across different

 * content-tree objects and different target formats.

 *

 * <p>

 * The following CFG gives the proper sequence of method invocation.

 *

 * <pre>

 * MARSHALLING  :=  ELEMENT

 * ELEMENT      :=  "startElement" NSDECL* "endNamespaceDecls"

 *                        ATTRIBUTE* "endAttributes" BODY "endElement"

 *

 * NSDECL       :=  "declareNamespace"

 *

 * ATTRIBUTE    :=  "attribute"

 * ATTVALUES    :=  "text"*

 *

 *

 * BODY         :=  ( "text" | ELEMENT )*

 * </pre>

 *

 * <p>

 * A marshalling of one element consists of two stages. The first stage is

 * for marshalling attributes and collecting namespace declarations.

 * The second stage is for marshalling characters/child elements of that element.

 *

 * <p>

 * Observe that multiple invocation of "text" is allowed.

 *

 * <p>

 * Also observe that the namespace declarations are allowed only between

 * "startElement" and "endAttributes".

 *

 * <h2>Exceptions in marshaller</h2>

 * <p>

 * {@link IOException}, {@link SAXException}, and {@link XMLStreamException}

 * are thrown from {@link XmlOutput}. They are always considered fatal, and

 * therefore caught only by {@link MarshallerImpl}.

 * <p>

 * {@link AccessorException} can be thrown when an access to a property/field

 * fails, and this is considered as a recoverable error, so it's caught everywhere.

 *

 * @author  Kohsuke Kawaguchi

 */

public final class XMLSerializer extends Coordinator {

    public final JAXBContextImpl grammar;

    /** The XML printer. */

    private XmlOutput out;

    public final NameList nameList;

    public final int[] knownUri2prefixIndexMap;

    private final NamespaceContextImpl nsContext;

    private NamespaceContextImpl.Element nse;

    // Introduced based on Jersey requirements - to be able to retrieve marshalled name

    ThreadLocal<Property> currentProperty = new ThreadLocal<Property>();

    /**

     * Set to true if a text is already written,

     * and we need to print ' ' for additional text methods.

     */

    private boolean textHasAlreadyPrinted = false;

    /**

     * Set to false once we see the start tag of the root element.

     */

    private boolean seenRoot = false;

    /** Marshaller object to which this object belongs. */

    private final MarshallerImpl marshaller;

    /** Objects referenced through IDREF. */

    private final Set<Object> idReferencedObjects = new HashSet<Object>();

    /** Objects with ID. */

    private final Set<Object> objectsWithId = new HashSet<Object>();

    /**

     * Used to detect cycles in the object.

     * Also used to learn what's being marshalled.

     */

    private final CollisionCheckStack<Object> cycleDetectionStack = new CollisionCheckStack<Object>();

    /** Optional attributes to go with root element. */

    private String schemaLocation;

    private String noNsSchemaLocation;

    /** Lazily created identitiy transformer. */

    private Transformer identityTransformer;

    /** Lazily created. */

    private ContentHandlerAdaptor contentHandlerAdapter;

    private boolean fragment;

    /**

     * Cached instance of {@link Base64Data}.

     */

    private Base64Data base64Data;

    /**

     * Cached instance of {@link IntData}.

     */

    private final IntData intData = new IntData();

    public AttachmentMarshaller attachmentMarshaller;

    /*package*/ XMLSerializer( MarshallerImpl _owner ) {

        this.marshaller = _owner;

        this.grammar = marshaller.context;

        nsContext = new NamespaceContextImpl(this);

        nameList = marshaller.context.nameList;

        knownUri2prefixIndexMap = new int[nameList.namespaceURIs.length];

    }

    /**

     * Gets the cached instance of {@link Base64Data}.

     *

     * @deprecated

     *      {@link Base64Data} is no longer cached, so that

     *      XMLStreamWriterEx impl can retain the data, like JAX-WS does.

     */

    public Base64Data getCachedBase64DataInstance() {

        return new Base64Data();

    }

    /**

     * Gets the ID value from an identifiable object.

     */

    private String getIdFromObject(Object identifiableObject) throws SAXException, JAXBException {

        return grammar.getBeanInfo(identifiableObject,true).getId(identifiableObject,this);

    }

    private void handleMissingObjectError(String fieldName) throws SAXException, IOException, XMLStreamException {

        reportMissingObjectError(fieldName);

        // as a marshaller, we should be robust, so we'll continue to marshal

        // this document by skipping this missing object.

        endNamespaceDecls(null);

        endAttributes();

    }

    public void reportError( ValidationEvent ve ) throws SAXException {

        ValidationEventHandler handler;

        try {

            handler = marshaller.getEventHandler();

        } catch( JAXBException e ) {

            throw new SAXException2(e);

        }

        if(!handler.handleEvent(ve)) {

            if(ve.getLinkedException() instanceof Exception)

                throw new SAXException2((Exception)ve.getLinkedException());

            else

                throw new SAXException2(ve.getMessage());

        }

    }

    /**

     * Report an error found as an exception.

     *

     * @param fieldName

     *      the name of the property being processed when an error is found.

     */

    public final void reportError(String fieldName, Throwable t) throws SAXException {

        ValidationEvent ve = new ValidationEventImpl(ValidationEvent.ERROR,

            t.getMessage(), getCurrentLocation(fieldName), t);

        reportError(ve);

    }

    public void startElement(Name tagName, Object outerPeer) {

        startElement();

        nse.setTagName(tagName,outerPeer);

    }

    public void startElement(String nsUri, String localName, String preferredPrefix, Object outerPeer) {

        startElement();

        int idx = nsContext.declareNsUri(nsUri, preferredPrefix, false);

        nse.setTagName(idx,localName,outerPeer);

    }

    /**

     * Variation of {@link #startElement(String, String, String, Object)} that forces

     * a specific prefix. Needed to preserve the prefix when marshalling DOM.

     */

    public void startElementForce(String nsUri, String localName, String forcedPrefix, Object outerPeer) {

        startElement();

        int idx = nsContext.force(nsUri, forcedPrefix);

        nse.setTagName(idx,localName,outerPeer);

    }

    public void endNamespaceDecls(Object innerPeer) throws IOException, XMLStreamException {

        nsContext.collectionMode = false;

        nse.startElement(out,innerPeer);

    }

    /**

     * Switches to the "marshal child texts/elements" mode.

     * This method has to be called after the 1st pass is completed.

     */

    public void endAttributes() throws SAXException, IOException, XMLStreamException  {

        if(!seenRoot) {

            seenRoot = true;

            if(schemaLocation!=null || noNsSchemaLocation!=null) {

                int p = nsContext.getPrefixIndex(WellKnownNamespace.XML_SCHEMA_INSTANCE);

                if(schemaLocation!=null)

                    out.attribute(p,"schemaLocation",schemaLocation);

                if(noNsSchemaLocation!=null)

                    out.attribute(p,"noNamespaceSchemaLocation",noNsSchemaLocation);

            }

        }

        out.endStartTag();

    }

    /**

     * Ends marshalling of an element.

     * Pops the internal stack.

     */

    public void endElement() throws SAXException, IOException, XMLStreamException {

        nse.endElement(out);

        nse = nse.pop();

        textHasAlreadyPrinted = false;

    }

    public void leafElement( Name tagName, String data, String fieldName ) throws SAXException, IOException, XMLStreamException {

        if(seenRoot) {

            textHasAlreadyPrinted = false;

            nse = nse.push();

            out.beginStartTag(tagName);

            out.endStartTag();

            if(data != null)

                try {

                        out.text(data,false);

                } catch (IllegalArgumentException e) {

                    throw new IllegalArgumentException(Messages.ILLEGAL_CONTENT.format(fieldName, e.getMessage()));

                }

            out.endTag(tagName);

            nse = nse.pop();

        } else {

            // root element has additional processing like xsi:schemaLocation,

            // so we need to go the slow way

            startElement(tagName,null);

            endNamespaceDecls(null);

            endAttributes();

                try {

                    out.text(data, false);

                } catch (IllegalArgumentException e) {

                    throw new IllegalArgumentException(Messages.ILLEGAL_CONTENT.format(fieldName, e.getMessage()));

                }

            endElement();

        }

    }

    public void leafElement( Name tagName, Pcdata data, String fieldName ) throws SAXException, IOException, XMLStreamException {

        if(seenRoot) {

            textHasAlreadyPrinted = false;

            nse = nse.push();

            out.beginStartTag(tagName);

            out.endStartTag();

            if(data != null)

                out.text(data,false);

            out.endTag(tagName);

            nse = nse.pop();

        } else {

            // root element has additional processing like xsi:schemaLocation,

            // so we need to go the slow way

            startElement(tagName,null);

            endNamespaceDecls(null);

            endAttributes();

            out.text(data,false);

            endElement();

        }

    }

    public void leafElement( Name tagName, int data, String fieldName ) throws SAXException, IOException, XMLStreamException {

        intData.reset(data);

        leafElement(tagName,intData,fieldName);

    }

    /**

     * Marshalls text.

     *

     * <p>

     * This method can be called after the {@link #endAttributes()}

     * method to marshal texts inside elements.

     * If the method is called more than once, those texts are considered

     * as separated by whitespaces. For example,

     *

     * <pre>

     * c.startElement("","foo");

     * c.endAttributes();

     * c.text("abc");

     * c.text("def");

     *   c.startElement("","bar");

     *   c.endAttributes();

     *   c.endElement();

     * c.text("ghi");

     * c.endElement();

     * </pre>

     *

     */

    public void text( String text, String fieldName ) throws SAXException, IOException, XMLStreamException {

        // If the assertion fails, it must be a bug of xjc.

        // right now, we are not expecting the text method to be called.

        if(text==null) {

            reportMissingObjectError(fieldName);

            return;

        }

        out.text(text,textHasAlreadyPrinted);

        textHasAlreadyPrinted = true;

    }

    /**

     * The {@link #text(String, String)} method that takes {@link Pcdata}.

     */

    public void text( Pcdata text, String fieldName ) throws SAXException, IOException, XMLStreamException {

        // If the assertion fails, it must be a bug of xjc.

        // right now, we are not expecting the text method to be called.

        if(text==null) {

            reportMissingObjectError(fieldName);

            return;

        }

        out.text(text,textHasAlreadyPrinted);

        textHasAlreadyPrinted = true;

    }

    public void attribute(String uri, String local, String value) throws SAXException {

        int prefix;

        if(uri.length()==0) {

            // default namespace. don't need prefix

            prefix = -1;

        } else {

            prefix = nsContext.getPrefixIndex(uri);

        }

        try {

            out.attribute(prefix,local,value);

        } catch (IOException e) {

            throw new SAXException2(e);

        } catch (XMLStreamException e) {

            throw new SAXException2(e);

        }

    }

    public void attribute(Name name, CharSequence value) throws IOException, XMLStreamException {

        // TODO: consider having the version that takes Pcdata.

        // it's common for an element to have int attributes

        out.attribute(name,value.toString());

    }

    public NamespaceContext2 getNamespaceContext() {

        return nsContext;

    }

    public String onID( Object owner, String value ) {

        objectsWithId.add(owner);

        return value;

    }

    public String onIDREF( Object obj ) throws SAXException {

        String id;

        try {

            id = getIdFromObject(obj);

        } catch (JAXBException e) {

            reportError(null,e);

            return null; // recover by returning null

        }

        idReferencedObjects.add(obj);

        if(id==null) {

            reportError( new NotIdentifiableEventImpl(

                ValidationEvent.ERROR,

                Messages.NOT_IDENTIFIABLE.format(),

                new ValidationEventLocatorImpl(obj) ) );

        }

        return id;

    }

    // TODO: think about the exception handling.

    // I suppose we don't want to use SAXException. -kk

    public void childAsRoot(Object obj) throws JAXBException, IOException, SAXException, XMLStreamException {

        final JaxBeanInfo beanInfo = grammar.getBeanInfo(obj, true);

        // since the same object will be reported to childAsRoot or

        // childAsXsiType, don't make it a part of the collision check.

        // but we do need to push it so that getXMIMEContentType will work.

        cycleDetectionStack.pushNocheck(obj);

        final boolean lookForLifecycleMethods = beanInfo.lookForLifecycleMethods();

        if (lookForLifecycleMethods) {

            fireBeforeMarshalEvents(beanInfo, obj);

        }

        beanInfo.serializeRoot(obj,this);

        if (lookForLifecycleMethods) {

            fireAfterMarshalEvents(beanInfo, obj);

        }

        cycleDetectionStack.pop();

    }

    /**

     * Pushes the object to {@link #cycleDetectionStack} and also

     * detect any cycles.

     *

     * When a cycle is found, this method tries to recover from it.

     *

     * @return

     *      or null if the error is found and we need to avoid marshalling this object

     *      to prevent infinite recursion. When this method returns null, the error

     *      has already been reported.

     */

    private Object pushObject(Object obj, String fieldName) throws SAXException {

        if(!cycleDetectionStack.push(obj))

            return obj;

        // allow the object to nominate its replacement

        if(obj instanceof CycleRecoverable) {

            obj = ((CycleRecoverable)obj).onCycleDetected(new CycleRecoverable.Context(){

                public Marshaller getMarshaller() {

                    return marshaller;

                }

            });

            if(obj!=null) {

                // object nominated its replacement.

                // we still need to make sure that the nominated.

                // this may cause inifinite recursion on its own.

                cycleDetectionStack.pop();

                return pushObject(obj,fieldName);

            } else

                return null;

        }

        // cycle detected and no one is catching the error.

        reportError(new ValidationEventImpl(

            ValidationEvent.ERROR,

            Messages.CYCLE_IN_MARSHALLER.format(cycleDetectionStack.getCycleString()),

            getCurrentLocation(fieldName),

            null));

        return null;

    }