/*

 * 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.unmarshaller;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Callable;

import javax.xml.XMLConstants;

import javax.xml.bind.JAXBElement;

import javax.xml.bind.UnmarshalException;

import javax.xml.bind.Unmarshaller;

import javax.xml.bind.ValidationEvent;

import javax.xml.bind.ValidationEventHandler;

import javax.xml.bind.ValidationEventLocator;

import javax.xml.bind.helpers.ValidationEventImpl;

import javax.xml.namespace.NamespaceContext;

import javax.xml.namespace.QName;

import com.sun.istack.internal.NotNull;

import com.sun.istack.internal.Nullable;

import com.sun.istack.internal.SAXParseException2;

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

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

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

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

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

import com.sun.xml.internal.bind.v2.runtime.AssociationMap;

import com.sun.xml.internal.bind.v2.runtime.Coordinator;

import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl;

import com.sun.xml.internal.bind.v2.runtime.JaxBeanInfo;

import org.xml.sax.ErrorHandler;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.LocatorImpl;

/**

 * Center of the unmarshalling.

 *

 * <p>

 * This object is responsible for coordinating {@link Loader}s to

 * perform the whole unmarshalling.

 *

 * @author Kohsuke Kawaguchi

 */

public final class UnmarshallingContext extends Coordinator

    implements NamespaceContext, ValidationEventHandler, ErrorHandler, XmlVisitor, XmlVisitor.TextPredictor {

    /**

     * Root state.

     */

    private final State root;

    /**

     * The currently active state.

     */

    private State current;

    private static final LocatorEx DUMMY_INSTANCE;

    static {

        LocatorImpl loc = new LocatorImpl();

        loc.setPublicId(null);

        loc.setSystemId(null);

        loc.setLineNumber(-1);

        loc.setColumnNumber(-1);

        DUMMY_INSTANCE = new LocatorExWrapper(loc);

    }

    private @NotNull LocatorEx locator = DUMMY_INSTANCE;

    /** Root object that is being unmarshalled. */

    private Object result;

    /**

     * If non-null, this unmarshaller will unmarshal {@code JAXBElement<EXPECTEDTYPE>}

     * regardless of the tag name, as opposed to deciding the root object by using

     * the tag name.

     *

     * The property has a package-level access, because we cannot copy this value

     * to {@link UnmarshallingContext} when it is created. The property

     * on {@link Unmarshaller} could be changed after the handler is created.

     */

    private JaxBeanInfo expectedType;

    /**

     * Handles ID/IDREF.

     */

    private IDResolver idResolver;

    /**

     * This flag is set to true at the startDocument event

     * and false at the endDocument event.

     *

     * Until the first document is unmarshalled, we don't

     * want to return an object. So this variable is initialized

     * to true.

     */

    private boolean isUnmarshalInProgress = true;

    private boolean aborted = false;

    public final UnmarshallerImpl parent;

    /**

     * If the unmarshaller is doing associative unmarshalling,

     * this field is initialized to non-null.

     */

    private final AssociationMap assoc;

    /**

     * Indicates whether we are doing in-place unmarshalling

     * or not.

     *

     * <p>

     * This flag is unused when {@link #assoc}==null.

     * If it's non-null, then <tt>true</tt> indicates

     * that we are doing in-place associative unmarshalling.

     * If <tt>false</tt>, then we are doing associative unmarshalling

     * without object reuse.

     */

    private boolean isInplaceMode;

    /**

     * This object is consulted to get the element object for

     * the current element event.

     *

     * This is used when we are building an association map.

     */

    private InfosetScanner scanner;

    private Object currentElement;

    /**

     * @see XmlVisitor#startDocument(LocatorEx, NamespaceContext)

     */

    private NamespaceContext environmentNamespaceContext;

    /**

     * Used to discover additional classes when we hit unknown elements/types.

     */

    public @Nullable ClassResolver classResolver;

    /**

     * User-supplied {@link ClassLoader} for converting name to {@link Class}.

     * For backward compatibility, when null, use thread context classloader.

     */

    public @Nullable ClassLoader classLoader;

    /**

     * State information for each element.

     */

    public final class State {

        /**

         * Loader that owns this element.

         */

        public Loader loader;

        /**

         * Once {@link #loader} is completed, this receiver

         * receives the result.

         */

        public Receiver receiver;

        public Intercepter intercepter;

        /**

         * Object being unmarshalled by this {@link #loader}.

         */

        public Object target;

        /**

         * Hack for making JAXBElement unmarshalling work.

         *

         * <p>

         * While the unmarshalling is in progress, the {@link #target} field stores the object being unmarshalled.

         * This makes it convenient to keep track of the unmarshalling activity in context of XML infoset, but

         * since there's only one {@link State} per element, this mechanism only works when there's one object

         * per element, which breaks down when we have {@link JAXBElement}, since the presence of JAXBElement

         * requires that we have two objects unmarshalled (a JAXBElement X and a value object Y bound to an XML type.)

         *

         * <p>

         * So to make room for storing both, this {@link #backup} field is used. When we create X instance

         * in the above example, we set that to {@code state.prev.target} and displace its old value to

         * {@code state.prev.backup} (where Y goes to {@code state.target}.) Upon the completion of the unmarshalling

         * of Y, we revert this.

         *

         * <p>

         * While this attributes X incorrectly to its parent element, this preserves the parent/child

         * relationship between unmarshalled objects and {@link State} parent/child relationship, and

         * it thereby makes {@link Receiver} mechanism simpler.

         *

         * <p>

         * Yes, I know this is a hack, and no, I'm not proud of it.

         *

         * @see ElementBeanInfoImpl.IntercepterLoader#startElement(State, TagName)

         * @see ElementBeanInfoImpl.IntercepterLoader#intercept(State, Object)

         */

        public Object backup;

        /**

         * Number of {@link UnmarshallingContext#nsBind}s declared thus far.

         * (The value of {@link UnmarshallingContext#nsLen} when this state is pushed.

         */

        private int numNsDecl;

        /**

         * If this element has an element default value.

         *

         * This should be set by either a parent {@link Loader} when

         * {@link Loader#childElement(State, TagName)} is called

         * or by a child {@link Loader} when

         * {@link Loader#startElement(State, TagName)} is called.

         */

        public String elementDefaultValue;

        /**

         * {@link State} for the parent element

         *

         * {@link State} objects form a doubly linked list.

         */

        public State prev;

        private State next;

        public boolean nil = false;

        /**

         * Gets the context.

         */

        public UnmarshallingContext getContext() {

            return UnmarshallingContext.this;

        }

        private State(State prev) {

            this.prev = prev;

                prev.next = this;

        }

        private void push() {

                allocateMoreStates();

            State n = next;

            n.numNsDecl = nsLen;

            current = n;

        }

        private void pop() {

            assert prev!=null;

            loader = null;

            nil = false;

            receiver = null;

            intercepter = null;

            elementDefaultValue = null;

            target = null;

            current = prev;

        }

    }

    /**

     * Stub to the user-specified factory method.

     */

    private static class Factory {

        private final Object factorInstance;

        private final Method method;

        public Factory(Object factorInstance, Method method) {

            this.factorInstance = factorInstance;

            this.method = method;

        }

        public Object createInstance() throws SAXException {

            try {

                return method.invoke(factorInstance);

            } catch (IllegalAccessException e) {

                getInstance().handleError(e,false);

            } catch (InvocationTargetException e) {

                getInstance().handleError(e,false);

            }

            return null; // can never be executed

        }

    }

    /**

     * Creates a new unmarshaller.

     *

     * @param assoc

     *      Must be both non-null when the unmarshaller does the

     *      in-place unmarshalling. Otherwise must be both null.

     */

    public UnmarshallingContext( UnmarshallerImpl _parent, AssociationMap assoc) {

        this.parent = _parent;

        this.assoc = assoc;

        this.root = this.current = new State(null);

        allocateMoreStates();

    }

    public void reset(InfosetScanner scanner,boolean isInplaceMode, JaxBeanInfo expectedType, IDResolver idResolver) {

        this.scanner = scanner;

        this.isInplaceMode = isInplaceMode;

        this.expectedType = expectedType;

        this.idResolver = idResolver;

    }

    public JAXBContextImpl getJAXBContext() {

        return parent.context;

    }

    public State getCurrentState() {

        return current;

    }

    /**

     * On top of {@link JAXBContextImpl#selectRootLoader(State, TagName)},

     * this method also consults {@link ClassResolver}.

     *

     * @throws SAXException

     *      if {@link ValidationEventHandler} reported a failure.

     */

    public Loader selectRootLoader(State state, TagName tag) throws SAXException {

        try {

            Loader l = getJAXBContext().selectRootLoader(state, tag);

            if(l!=null)     return l;

            if(classResolver!=null) {

                Class<?> clazz = classResolver.resolveElementName(tag.uri, tag.local);

                if(clazz!=null) {

                    JAXBContextImpl enhanced = getJAXBContext().createAugmented(clazz);

                    JaxBeanInfo<?> bi = enhanced.getBeanInfo(clazz);

                    return bi.getLoader(enhanced,true);

                }

            }

        } catch (RuntimeException e) {

            throw e;

        } catch (Exception e) {

            handleError(e);

        }

        return null;

    }

    /**

     * Allocates a few more {@link State}s.

     *

     * Allocating multiple {@link State}s at once allows those objects

     * to be allocated near each other, which reduces the working set

     * of CPU. It improves the chance the relevant data is in the cache.

     */

    private void allocateMoreStates() {

        // this method should be used only when we run out of a state.

        assert current.next==null;

        State s = current;

            s = new State(s);

    }

    public void clearStates() {

        State last = current;

        while (last.next != null) last = last.next;

        while (last.prev != null) {

            last.loader = null;

            last.nil = false;

            last.receiver = null;

            last.intercepter = null;

            last.elementDefaultValue = null;

            last.target = null;

            last = last.prev;

            last.next.prev = null;

            last.next = null;

        }

        current = last;

    }

    /**

     * User-specified factory methods.

     */

    private final Map<Class,Factory> factories = new HashMap<Class, Factory>();

    public void setFactories(Object factoryInstances) {

        factories.clear();

        if(factoryInstances==null) {

            return;

        }

        if(factoryInstances instanceof Object[]) {

            for( Object factory : (Object[])factoryInstances ) {

                // look for all the public methods inlcuding derived ones

                addFactory(factory);

            }

        } else {

            addFactory(factoryInstances);

        }

    }

    private void addFactory(Object factory) {

        for( Method m : factory.getClass().getMethods() ) {

            // look for methods whose signature is T createXXX()

            if(!m.getName().startsWith("create"))

                continue;

            if(m.getParameterTypes().length>0)

                continue;

            Class type = m.getReturnType();

            factories.put(type,new Factory(factory,m));

        }

    }

    public void startDocument(LocatorEx locator, NamespaceContext nsContext) throws SAXException {

        if(locator!=null)

            this.locator = locator;

        this.environmentNamespaceContext = nsContext;

        // reset the object

        result = null;

        current = root;

        patchersLen=0;

        aborted = false;

        isUnmarshalInProgress = true;

        nsLen=0;

        if(expectedType!=null)

            root.loader = EXPECTED_TYPE_ROOT_LOADER;

        else

            root.loader = DEFAULT_ROOT_LOADER;

        idResolver.startDocument(this);

    }

    public void startElement(TagName tagName) throws SAXException {

        pushCoordinator();

        try {

            _startElement(tagName);

        } finally {

            popCoordinator();

        }

    }

    private void _startElement(TagName tagName) throws SAXException {

        // remember the current element if we are interested in it.

        // because the inner peer might not be found while we consume

        // the enter element token, we need to keep this information

        // longer than this callback. That's why we assign it to a field.

        if( assoc!=null )

            currentElement = scanner.getCurrentElement();

        Loader h = current.loader;

        current.push();

        // tell the parent about the new child

        h.childElement(current,tagName);

        assert current.loader!=null;   // the childElement should register this

        // and tell the new child that you are activated

        current.loader.startElement(current,tagName);

    }

    public void text(CharSequence pcdata) throws SAXException {

        State cur = current;

        pushCoordinator();

        try {

            if(cur.elementDefaultValue!=null) {

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

                    // send the default value into the unmarshaller instead

                    pcdata = cur.elementDefaultValue;