/*

 * 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.ref.WeakReference;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Type;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.TreeSet;

import javax.xml.bind.Binder;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBElement;

import javax.xml.bind.JAXBException;

import javax.xml.bind.JAXBIntrospector;

import javax.xml.bind.Marshaller;

import javax.xml.bind.SchemaOutputResolver;

import javax.xml.bind.Unmarshaller;

import javax.xml.bind.Validator;

import javax.xml.bind.annotation.XmlAttachmentRef;

import javax.xml.bind.annotation.XmlList;

import javax.xml.bind.annotation.XmlNs;

import javax.xml.bind.annotation.XmlSchema;

import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

import javax.xml.namespace.QName;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.FactoryConfigurationError;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.Result;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.sax.SAXTransformerFactory;

import javax.xml.transform.sax.TransformerHandler;

import com.sun.istack.internal.NotNull;

import com.sun.istack.internal.Pool;

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

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

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

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

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

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

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

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

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

import com.sun.xml.internal.bind.unmarshaller.DOMScanner;

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

import com.sun.xml.internal.bind.v2.model.annotation.RuntimeAnnotationReader;

import com.sun.xml.internal.bind.v2.model.annotation.RuntimeInlineAnnotationReader;

import com.sun.xml.internal.bind.v2.model.core.Adapter;

import com.sun.xml.internal.bind.v2.model.core.NonElement;

import com.sun.xml.internal.bind.v2.model.core.Ref;

import com.sun.xml.internal.bind.v2.model.impl.RuntimeBuiltinLeafInfoImpl;

import com.sun.xml.internal.bind.v2.model.impl.RuntimeModelBuilder;

import com.sun.xml.internal.bind.v2.model.nav.Navigator;

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

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

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

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

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

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

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

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

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

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

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

import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;

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

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

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

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

import com.sun.xml.internal.bind.v2.schemagen.XmlSchemaGenerator;

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

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

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

import com.sun.xml.internal.txw2.output.ResultFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

/**

 * This class provides the implementation of JAXBContext.

 *

 */

public final class JAXBContextImpl extends JAXBRIContext {

    /**

     * All the bridge classes.

     */

    private final Map<TypeReference,Bridge> bridges = new LinkedHashMap<TypeReference,Bridge>();

    /**

     * Shared instance of {@link TransformerFactory}.

     * Lock before use, because a {@link TransformerFactory} is not thread-safe

     * whereas {@link JAXBContextImpl} is.

     * Lazily created.

     */

    private volatile static SAXTransformerFactory tf;

    /**

     * Shared instance of {@link DocumentBuilder}.

     * Lock before use. Lazily created.

     */

    private static DocumentBuilder db;

    private final QNameMap<JaxBeanInfo> rootMap = new QNameMap<JaxBeanInfo>();

    private final HashMap<QName,JaxBeanInfo> typeMap = new HashMap<QName,JaxBeanInfo>();

    /**

     * Map from JAXB-bound {@link Class} to its {@link JaxBeanInfo}.

     */

    private final Map<Class,JaxBeanInfo> beanInfoMap = new LinkedHashMap<Class,JaxBeanInfo>();

    /**

     * All created {@link JaxBeanInfo}s.

     * Updated from each {@link JaxBeanInfo}s constructors to avoid infinite recursion

     * for a cyclic reference.

     *

     * <p>

     * This map is only used while the {@link JAXBContextImpl} is built and set to null

     * to avoid keeping references too long.

     */

    protected Map<RuntimeTypeInfo,JaxBeanInfo> beanInfos = new LinkedHashMap<RuntimeTypeInfo, JaxBeanInfo>();

    private final Map<Class/*scope*/,Map<QName,ElementBeanInfoImpl>> elements = new LinkedHashMap<Class, Map<QName, ElementBeanInfoImpl>>();

    /**

     * Pool of {@link Marshaller}s.

     */

    public final Pool<Marshaller> marshallerPool = new Pool.Impl<Marshaller>() {

        protected @NotNull Marshaller create() {

            return createMarshaller();

        }

    };

    public final Pool<Unmarshaller> unmarshallerPool = new Pool.Impl<Unmarshaller>() {

        protected @NotNull Unmarshaller create() {

            return createUnmarshaller();

        }

    };

    /**

     * Used to assign indices to known names in this grammar.

     * Reset to null once the build phase is completed.

     */

    public NameBuilder nameBuilder = new NameBuilder();

    /**

     * Keeps the list of known names.

     * This field is set once the build pahse is completed.

     */

    public final NameList nameList;

    /**

     * Input to the JAXBContext.newInstance, so that we can recreate

     * {@link RuntimeTypeInfoSet} whenever we need.

     */

    private final String defaultNsUri;

    private final Class[] classes;

    /**

     * true to reorder attributes lexicographically in preparation of the c14n support.

     */

    protected final boolean c14nSupport;

    /**

     * Flag that user has provided a custom AccessorFactory for JAXB to use

     */

    public final boolean xmlAccessorFactorySupport;

    /**

     * @see JAXBRIContext#TREAT_EVERYTHING_NILLABLE

     */

    public final boolean allNillable;

    /**

     * Store properties, so that they can be recovered in the run (is here because of JSON encoding of Jersey).

     */

    public final boolean retainPropertyInfo;

    /**

     * Suppress reflection accessor warnings.

     */

    public final boolean supressAccessorWarnings;

    /**

     * Improved xsi type handling.

     */

    public final boolean improvedXsiTypeHandling;

    /**

     * Disable security processing.

     */

    public final boolean disableSecurityProcessing;

    private WeakReference<RuntimeTypeInfoSet> typeInfoSetCache;

    private @NotNull RuntimeAnnotationReader annotationReader;

    private /*almost final*/ boolean hasSwaRef;

    private final @NotNull Map<Class,Class> subclassReplacements;

    /**

     * If true, we aim for faster {@link JAXBContext} instantiation performance,

     * instead of going after efficient sustained unmarshalling/marshalling performance.

     *

     * @since 2.0.4

     */

    public final boolean fastBoot;

    private Set<XmlNs> xmlNsSet = null;

    /**

     * Returns declared XmlNs annotations (from package-level annotation XmlSchema

     *

     * @return set of all present XmlNs annotations

     */

    public Set<XmlNs> getXmlNsSet() {

        return xmlNsSet;

    }

    private JAXBContextImpl(JAXBContextBuilder builder) throws JAXBException {

        this.defaultNsUri = builder.defaultNsUri;

        this.retainPropertyInfo = builder.retainPropertyInfo;

        this.annotationReader = builder.annotationReader;

        this.subclassReplacements = builder.subclassReplacements;

        this.c14nSupport = builder.c14nSupport;

        this.classes = builder.classes;

        this.xmlAccessorFactorySupport = builder.xmlAccessorFactorySupport;

        this.allNillable = builder.allNillable;

        this.supressAccessorWarnings = builder.supressAccessorWarnings;

        this.improvedXsiTypeHandling = builder.improvedXsiTypeHandling;

        this.disableSecurityProcessing = builder.disableSecurityProcessing;

        Collection<TypeReference> typeRefs = builder.typeRefs;

        boolean fastB;

        try {

            fastB = Boolean.getBoolean(JAXBContextImpl.class.getName()+".fastBoot");

        } catch (SecurityException e) {

            fastB = false;

        }

        this.fastBoot = fastB;

        RuntimeTypeInfoSet typeSet = getTypeInfoSet();

        // at least prepare the empty table so that we don't have to check for null later

        elements.put(null,new LinkedHashMap<QName, ElementBeanInfoImpl>());

        // recognize leaf bean infos

        for( RuntimeBuiltinLeafInfo leaf : RuntimeBuiltinLeafInfoImpl.builtinBeanInfos ) {

            LeafBeanInfoImpl<?> bi = new LeafBeanInfoImpl(this,leaf);

            beanInfoMap.put(leaf.getClazz(),bi);

            for( QName t : bi.getTypeNames() )

                typeMap.put(t,bi);

        }

        for (RuntimeEnumLeafInfo e : typeSet.enums().values()) {

            JaxBeanInfo<?> bi = getOrCreate(e);

            for (QName qn : bi.getTypeNames())

                typeMap.put( qn, bi );

            if(e.isElement())

                rootMap.put( e.getElementName(), bi );

        }

        for (RuntimeArrayInfo a : typeSet.arrays().values()) {

            JaxBeanInfo<?> ai = getOrCreate(a);

            for (QName qn : ai.getTypeNames())

                typeMap.put( qn, ai );

        }

        for( Entry<Class, ? extends RuntimeClassInfo> e : typeSet.beans().entrySet() ) {

            ClassBeanInfoImpl<?> bi = getOrCreate(e.getValue());

            XmlSchema xs = this.annotationReader.getPackageAnnotation(XmlSchema.class, e.getKey(), null);

            if(xs != null) {

                if(xs.xmlns() != null && xs.xmlns().length > 0) {

                    if(xmlNsSet == null)

                        xmlNsSet = new HashSet<XmlNs>();

                    xmlNsSet.addAll(Arrays.asList(xs.xmlns()));

                }

            }

            if(bi.isElement())

                rootMap.put( e.getValue().getElementName(), bi );

            for (QName qn : bi.getTypeNames())

                typeMap.put( qn, bi );

        }

        // fill in element mappings

        for( RuntimeElementInfo n : typeSet.getAllElements() ) {

            ElementBeanInfoImpl bi = getOrCreate(n);

            if(n.getScope()==null)

                rootMap.put(n.getElementName(),bi);

            RuntimeClassInfo scope = n.getScope();

            Class scopeClazz = scope==null?null:scope.getClazz();

            Map<QName,ElementBeanInfoImpl> m = elements.get(scopeClazz);

            if(m==null) {

                m = new LinkedHashMap<QName, ElementBeanInfoImpl>();

                elements.put(scopeClazz,m);

            }

            m.put(n.getElementName(),bi);

        }

        // this one is so that we can handle plain JAXBElements.

        beanInfoMap.put(JAXBElement.class,new ElementBeanInfoImpl(this));

        // another special BeanInfoImpl just for marshalling

        beanInfoMap.put(CompositeStructure.class,new CompositeStructureBeanInfo(this));

        getOrCreate(typeSet.getAnyTypeInfo());

        // then link them all!

        for (JaxBeanInfo bi : beanInfos.values())

            bi.link(this);

        // register primitives for boxed types just to make GrammarInfo fool-proof

        for( Map.Entry<Class,Class> e : RuntimeUtil.primitiveToBox.entrySet() )

            beanInfoMap.put( e.getKey(), beanInfoMap.get(e.getValue()) );

        // build bridges

        for (TypeReference tr : typeRefs) {

            XmlJavaTypeAdapter xjta = tr.get(XmlJavaTypeAdapter.class);

            Adapter<Type,Class> a=null;

            XmlList xl = tr.get(XmlList.class);

            // eventually compute the in-memory type

            if(xjta!=null) {

                a = new Adapter<Type,Class>(xjta.value(),nav);

            }

            if(tr.get(XmlAttachmentRef.class)!=null) {

                a = new Adapter<Type,Class>(SwaRefAdapter.class,nav);

                hasSwaRef = true;

            }

            if(a!=null) {

            }

            Name name = nameBuilder.createElementName(tr.tagName);

            InternalBridge bridge;

            if(xl==null)

                bridge = new BridgeImpl(this, name,getBeanInfo(erasedType,true),tr);

            else

                bridge = new BridgeImpl(this, name,new ValueListBeanInfoImpl(this,erasedType),tr);

            if(a!=null)

                bridge = new BridgeAdapter(bridge,a.adapterType);

            bridges.put(tr,bridge);

        }

        this.nameList = nameBuilder.conclude();

        for (JaxBeanInfo bi : beanInfos.values())

            bi.wrapUp();

        // no use for them now

        nameBuilder = null;

        beanInfos = null;

    }

    /**

     * True if this JAXBContext has {@link XmlAttachmentRef}.

     */

    public boolean hasSwaRef() {

        return hasSwaRef;

    }

    public RuntimeTypeInfoSet getRuntimeTypeInfoSet() {

        try {

            return getTypeInfoSet();

        } catch (IllegalAnnotationsException e) {

            // impossible, once the model is constructred

            throw new AssertionError(e);

        }

    }

    /**

     * Creates a {@link RuntimeTypeInfoSet}.

     */

    public RuntimeTypeInfoSet getTypeInfoSet() throws IllegalAnnotationsException {

        // check cache

        if(typeInfoSetCache!=null) {

            RuntimeTypeInfoSet r = typeInfoSetCache.get();

            if(r!=null)

                return r;

        }

        final RuntimeModelBuilder builder = new RuntimeModelBuilder(this,annotationReader,subclassReplacements,defaultNsUri);

        IllegalAnnotationsException.Builder errorHandler = new IllegalAnnotationsException.Builder();

        builder.setErrorHandler(errorHandler);

        for( Class c : classes ) {

            if(c==CompositeStructure.class)

                // CompositeStructure doesn't have TypeInfo, so skip it.

                // We'll add JaxBeanInfo for this later automatically

                continue;

            builder.getTypeInfo(new Ref<Type,Class>(c));

        }

        this.hasSwaRef |= builder.hasSwaRef;

        RuntimeTypeInfoSet r = builder.link();

        errorHandler.check();

        assert r!=null : "if no error was reported, the link must be a success";

        typeInfoSetCache = new WeakReference<RuntimeTypeInfoSet>(r);

        return r;

    }

    public ElementBeanInfoImpl getElement(Class scope, QName name) {

        Map<QName,ElementBeanInfoImpl> m = elements.get(scope);

        if(m!=null) {

            ElementBeanInfoImpl bi = m.get(name);

            if(bi!=null)

                return bi;

        }

        m = elements.get(null);

        return m.get(name);

    }

    private ElementBeanInfoImpl getOrCreate( RuntimeElementInfo rei ) {

        JaxBeanInfo bi = beanInfos.get(rei);

        if(bi!=null)    return (ElementBeanInfoImpl)bi;

        // all elements share the same type, so we can't register them to beanInfoMap

        return new ElementBeanInfoImpl(this, rei);

    }

    protected JaxBeanInfo getOrCreate( RuntimeEnumLeafInfo eli ) {

        JaxBeanInfo bi = beanInfos.get(eli);

        if(bi!=null)    return bi;

        bi = new LeafBeanInfoImpl(this,eli);

        beanInfoMap.put(bi.jaxbType,bi);

        return bi;

    }

    protected ClassBeanInfoImpl getOrCreate( RuntimeClassInfo ci ) {

        ClassBeanInfoImpl bi = (ClassBeanInfoImpl)beanInfos.get(ci);

        if(bi!=null)    return bi;

        bi = new ClassBeanInfoImpl(this,ci);

        beanInfoMap.put(bi.jaxbType,bi);

        return bi;

    }

    protected JaxBeanInfo getOrCreate( RuntimeArrayInfo ai ) {

        JaxBeanInfo abi = beanInfos.get(ai);

        if(abi!=null)   return abi;

        abi = new ArrayBeanInfoImpl(this,ai);

        beanInfoMap.put(ai.getType(),abi);

        return abi;

    }

    public JaxBeanInfo getOrCreate(RuntimeTypeInfo e) {

        if(e instanceof RuntimeElementInfo)

            return getOrCreate((RuntimeElementInfo)e);

        if(e instanceof RuntimeClassInfo)

            return getOrCreate((RuntimeClassInfo)e);

        if(e instanceof RuntimeLeafInfo) {

            JaxBeanInfo bi = beanInfos.get(e); // must have been created

            assert bi!=null;

            return bi;

        }

        if(e instanceof RuntimeArrayInfo)

            return getOrCreate((RuntimeArrayInfo)e);

        if(e.getType()==Object.class) {

            // anyType

            JaxBeanInfo bi = beanInfoMap.get(Object.class);

            if(bi==null) {