/*

 * 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.ws.api.streaming;

import com.sun.istack.internal.NotNull;

import com.sun.istack.internal.Nullable;

import com.sun.xml.internal.ws.streaming.XMLReaderException;

import com.sun.xml.internal.ws.util.xml.XmlUtil;

import org.xml.sax.InputSource;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.StringReader;

import java.io.UnsupportedEncodingException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.URL;

import java.security.AccessController;

import java.util.logging.Level;

import java.util.logging.Logger;

import com.sun.xml.internal.ws.resources.StreamingMessages;

/**

 * Factory for {@link XMLStreamReader}.

 *

 * <p>

 * This wraps {@link XMLInputFactory} and allows us to reuse {@link XMLStreamReader} instances

 * when appropriate.

 *

 * @author Kohsuke Kawaguchi

 */

@SuppressWarnings("StaticNonFinalUsedInInitialization")

public abstract class XMLStreamReaderFactory {

    private static final Logger LOGGER = Logger.getLogger(XMLStreamReaderFactory.class.getName());

    private static final String CLASS_NAME_OF_WSTXINPUTFACTORY = "com.ctc.wstx.stax.WstxInputFactory";

    /**

     * Singleton instance.

     */

    private static volatile ContextClassloaderLocal<XMLStreamReaderFactory> streamReader =

            new ContextClassloaderLocal<XMLStreamReaderFactory>() {

                @Override

                protected XMLStreamReaderFactory initialValue() {

                    XMLInputFactory xif = getXMLInputFactory();

                    XMLStreamReaderFactory f=null;

                    // this system property can be used to disable the pooling altogether,

                    // in case someone hits an issue with pooling in the production system.

                    if(!getProperty(XMLStreamReaderFactory.class.getName()+".noPool")) {

                        f = Zephyr.newInstance(xif);

                    }

                    if(f==null) {

                        // is this Woodstox?

                        if (xif.getClass().getName().equals(CLASS_NAME_OF_WSTXINPUTFACTORY)) {

                            f = new Woodstox(xif);

                        }

                    }

                    if (f==null) {

                        f = new Default();

                    }

                    if (LOGGER.isLoggable(Level.FINE)) {

                        LOGGER.log(Level.FINE, "XMLStreamReaderFactory instance is = {0}", f);

                    }

                    return f;

                }

            };

    private static XMLInputFactory getXMLInputFactory() {

        XMLInputFactory xif = null;

        if (getProperty(XMLStreamReaderFactory.class.getName()+".woodstox")) {

            try {

                xif = (XMLInputFactory)Class.forName("com.ctc.wstx.stax.WstxInputFactory").newInstance();

            } catch (Exception e) {

                if (LOGGER.isLoggable(Level.WARNING)) {

                    LOGGER.log(Level.WARNING, StreamingMessages.WOODSTOX_CANT_LOAD(CLASS_NAME_OF_WSTXINPUTFACTORY), e);

                }

            }

        }

        if (xif == null) {

             xif = XmlUtil.newXMLInputFactory(true);

        }

        xif.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, true);

        xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);

        xif.setProperty(XMLInputFactory.IS_COALESCING, true);

        return xif;

    }

    /**

     * Overrides the singleton {@link XMLStreamReaderFactory} instance that

     * the JAX-WS RI uses.

     */

    public static void set(XMLStreamReaderFactory f) {

        if(f==null) {

            throw new IllegalArgumentException();

        }

        streamReader.set(f);

    }

    public static XMLStreamReaderFactory get() {

        return streamReader.get();

    }

    public static XMLStreamReader create(InputSource source, boolean rejectDTDs) {

        try {

            // Char stream available?

            if (source.getCharacterStream() != null) {

                return get().doCreate(source.getSystemId(), source.getCharacterStream(), rejectDTDs);

            }

            // Byte stream available?

            if (source.getByteStream() != null) {

                return get().doCreate(source.getSystemId(), source.getByteStream(), rejectDTDs);

            }

            // Otherwise, open URI

            return get().doCreate(source.getSystemId(), new URL(source.getSystemId()).openStream(),rejectDTDs);

        } catch (IOException e) {

            throw new XMLReaderException("stax.cantCreate",e);

        }

    }

    public static XMLStreamReader create(@Nullable String systemId, InputStream in, boolean rejectDTDs) {

        return get().doCreate(systemId,in,rejectDTDs);

    }

    public static XMLStreamReader create(@Nullable String systemId, InputStream in, @Nullable String encoding, boolean rejectDTDs) {

        return (encoding == null)

                ? create(systemId, in, rejectDTDs)

                : get().doCreate(systemId,in,encoding,rejectDTDs);

    }

    public static XMLStreamReader create(@Nullable String systemId, Reader reader, boolean rejectDTDs) {

        return get().doCreate(systemId,reader,rejectDTDs);

    }

    /**

     * Should be invoked when the code finished using an {@link XMLStreamReader}.

     *

     * <p>

     * If the recycled instance implements {@link RecycleAware},

     * {@link RecycleAware#onRecycled()} will be invoked to let the instance

     * know that it's being recycled.

     *

     * <p>

     * It is not a hard requirement to call this method on every {@link XMLStreamReader}

     * instance. Not doing so just reduces the performance by throwing away

     * possibly reusable instances. So the caller should always consider the effort

     * it takes to recycle vs the possible performance gain by doing so.

     *

     * <p>

     * This method may be invoked by multiple threads concurrently.

     *

     * @param r

     *      The {@link XMLStreamReader} instance that the caller finished using.

     *      This could be any {@link XMLStreamReader} implementation, not just

     *      the ones that were created from this factory. So the implementation

     *      of this class needs to be aware of that.

     */

    public static void recycle(XMLStreamReader r) {

        get().doRecycle(r);

        if (r instanceof RecycleAware) {

            ((RecycleAware)r).onRecycled();

    }

    // implementations

    public abstract XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs);

    private XMLStreamReader doCreate(String systemId, InputStream in, @NotNull String encoding, boolean rejectDTDs) {

        Reader reader;

        try {

            reader = new InputStreamReader(in, encoding);

        } catch(UnsupportedEncodingException ue) {

            throw new XMLReaderException("stax.cantCreate", ue);

        }

        return doCreate(systemId, reader, rejectDTDs);

    }

    public abstract XMLStreamReader doCreate(String systemId, Reader reader, boolean rejectDTDs);

    public abstract void doRecycle(XMLStreamReader r);

    /**

     * Interface that can be implemented by {@link XMLStreamReader} to

     * be notified when it's recycled.

     *

     * <p>

     * This provides a filtering {@link XMLStreamReader} an opportunity to

     * recycle its inner {@link XMLStreamReader}.

     */

    public interface RecycleAware {

        void onRecycled();

    }

    /**

     * {@link XMLStreamReaderFactory} implementation for SJSXP/JAXP RI.

     */

    private static final class Zephyr extends XMLStreamReaderFactory {

        private final XMLInputFactory xif;

        private final ThreadLocal<XMLStreamReader> pool = new ThreadLocal<XMLStreamReader>();

        /**

         * Sun StAX impl <code>XMLReaderImpl.setInputSource()</code> method via reflection.

         */

        private final Method setInputSourceMethod;

        /**

         * Sun StAX impl <code>XMLReaderImpl.reset()</code> method via reflection.

         */

        private final Method resetMethod;

        /**

         * The Sun StAX impl's {@link XMLStreamReader} implementation clas.

         */

        private final Class zephyrClass;

        /**

         * Creates {@link Zephyr} instance if the given {@link XMLInputFactory} is the one

         * from Zephyr.

         */

        public static @Nullable

        XMLStreamReaderFactory newInstance(XMLInputFactory xif) {

            // check if this is from Zephyr

            try {

                Class<?> clazz = xif.createXMLStreamReader(new StringReader("<foo/>")).getClass();

                // JDK has different XMLStreamReader impl class. Even if we check for that,

                // it doesn't have setInputSource(InputSource). Let it use Default

                if(!(clazz.getName().startsWith("com.sun.xml.internal.stream.")) )

                    return null;    // nope

                return new Zephyr(xif,clazz);

            } catch (NoSuchMethodException e) {

                return null;    // this factory is not for zephyr

            } catch (XMLStreamException e) {

                return null;    // impossible to fail to parse <foo/>, but anyway

            }

        }

        public Zephyr(XMLInputFactory xif, Class clazz) throws NoSuchMethodException {

            zephyrClass = clazz;

            setInputSourceMethod = clazz.getMethod("setInputSource", InputSource.class);

            resetMethod = clazz.getMethod("reset");

            try {

                // Turn OFF internal factory caching in Zephyr.

                // Santiago told me that this makes it thread-safe.

                xif.setProperty("reuse-instance", false);

            } catch (IllegalArgumentException e) {

                // falls through

            }

            this.xif = xif;

        }

        /**

         * Fetchs an instance from the pool if available, otherwise null.

         */

        private @Nullable XMLStreamReader fetch() {

            XMLStreamReader sr = pool.get();

            if(sr==null)    return null;

            pool.set(null);

            return sr;

        }

        @Override

        public void doRecycle(XMLStreamReader r) {

            if(zephyrClass.isInstance(r))

                pool.set(r);

        }

        @Override

        public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {

            try {

                XMLStreamReader xsr = fetch();

                if(xsr==null)

                    return xif.createXMLStreamReader(systemId,in);

                // try re-using this instance.

                InputSource is = new InputSource(systemId);

                is.setByteStream(in);

                reuse(xsr,is);

                return xsr;

            } catch (IllegalAccessException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            } catch (InvocationTargetException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            } catch (XMLStreamException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            }

        }

        @Override

        public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {

            try {

                XMLStreamReader xsr = fetch();

                if(xsr==null)

                    return xif.createXMLStreamReader(systemId,in);

                // try re-using this instance.

                InputSource is = new InputSource(systemId);

                is.setCharacterStream(in);

                reuse(xsr,is);

                return xsr;

            } catch (IllegalAccessException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            } catch (InvocationTargetException e) {

                Throwable cause = e.getCause();

                if (cause == null) {

                    cause = e;

                }

                throw new XMLReaderException("stax.cantCreate", cause);

            } catch (XMLStreamException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            }

        }

        private void reuse(XMLStreamReader xsr, InputSource in) throws IllegalAccessException, InvocationTargetException {

            resetMethod.invoke(xsr);

            setInputSourceMethod.invoke(xsr,in);

        }

    }

    /**

     * Default {@link XMLStreamReaderFactory} implementation

     * that can work with any {@link XMLInputFactory}.

     *

     * <p>

     * {@link XMLInputFactory} is not required to be thread-safe, but

     * if the create method on this implementation is synchronized,

     * it may run into (see <a href="https://jax-ws.dev.java.net/issues/show_bug.cgi?id=555">

     * race condition</a>). Hence, using a XMLInputFactory per thread.

     */

    public static final class Default extends XMLStreamReaderFactory {

        private final ThreadLocal<XMLInputFactory> xif = new ThreadLocal<XMLInputFactory>() {

            @Override

            public XMLInputFactory initialValue() {

                return getXMLInputFactory();

            }

        };

        @Override

        public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {

            try {

                return xif.get().createXMLStreamReader(systemId,in);

            } catch (XMLStreamException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            }

        }

        @Override

        public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {

            try {

                return xif.get().createXMLStreamReader(systemId,in);

            } catch (XMLStreamException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            }

        }

        @Override

        public void doRecycle(XMLStreamReader r) {

            // there's no way to recycle with the default StAX API.

        }

    }

    /**

     * Similar to {@link Default} but doesn't do any synchronization.

     *

     * <p>

     * This is useful when you know your {@link XMLInputFactory} is thread-safe by itself.

     */

    public static class NoLock extends XMLStreamReaderFactory {

        private final XMLInputFactory xif;

        public NoLock(XMLInputFactory xif) {

            this.xif = xif;

        }

        @Override

        public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {

            try {

                return xif.createXMLStreamReader(systemId,in);

            } catch (XMLStreamException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            }

        }

        @Override

        public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {

            try {

                return xif.createXMLStreamReader(systemId,in);

            } catch (XMLStreamException e) {

                throw new XMLReaderException("stax.cantCreate",e);

            }

        }

        @Override

        public void doRecycle(XMLStreamReader r) {

            // there's no way to recycle with the default StAX API.

        }

    }

    /**

     * Handles Woodstox's XIF, but sets properties to do the string interning, sets various limits, ...

     * Woodstox {@link XMLInputFactory} is thread safe.

     */

    public static final class Woodstox extends NoLock {

        public final static String PROPERTY_MAX_ATTRIBUTES_PER_ELEMENT = "xml.ws.maximum.AttributesPerElement";

        public final static String PROPERTY_MAX_ATTRIBUTE_SIZE = "xml.ws.maximum.AttributeSize";

        public final static String PROPERTY_MAX_CHILDREN_PER_ELEMENT = "xml.ws.maximum.ChildrenPerElement";

        public final static String PROPERTY_MAX_ELEMENT_COUNT = "xml.ws.maximum.ElementCount";

        public final static String PROPERTY_MAX_ELEMENT_DEPTH = "xml.ws.maximum.ElementDepth";

        public final static String PROPERTY_MAX_CHARACTERS = "xml.ws.maximum.Characters";

        private static final int DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT = 500;

        private static final int DEFAULT_MAX_ATTRIBUTE_SIZE = 65536 * 8;

        private static final int DEFAULT_MAX_CHILDREN_PER_ELEMENT = Integer.MAX_VALUE;

        private static final int DEFAULT_MAX_ELEMENT_DEPTH = 500;

        private static final long DEFAULT_MAX_ELEMENT_COUNT = Integer.MAX_VALUE;

        private static final long DEFAULT_MAX_CHARACTERS = Long.MAX_VALUE;

        /* Woodstox default setting:

         int mMaxAttributesPerElement = 1000;

         int mMaxAttributeSize = 65536 * 8;

         int mMaxChildrenPerElement = Integer.MAX_VALUE;

         int mMaxElementDepth = 1000;

         long mMaxElementCount = Long.MAX_VALUE;

         long mMaxCharacters = Long.MAX_VALUE;

         */

        private int maxAttributesPerElement = DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT;

        private int maxAttributeSize = DEFAULT_MAX_ATTRIBUTE_SIZE;

        private int maxChildrenPerElement = DEFAULT_MAX_CHILDREN_PER_ELEMENT;

        private int maxElementDepth = DEFAULT_MAX_ELEMENT_DEPTH;

        private long maxElementCount = DEFAULT_MAX_ELEMENT_COUNT;

        private long maxCharacters = DEFAULT_MAX_CHARACTERS;

        // Note: this is a copy from com.ctc.wstx.api.WstxInputProperties, to be removed in the future

        private static final java.lang.String P_MAX_ATTRIBUTES_PER_ELEMENT = "com.ctc.wstx.maxAttributesPerElement";

        private static final java.lang.String P_MAX_ATTRIBUTE_SIZE = "com.ctc.wstx.maxAttributeSize";

        private static final java.lang.String P_MAX_CHILDREN_PER_ELEMENT = "com.ctc.wstx.maxChildrenPerElement";

        private static final java.lang.String P_MAX_ELEMENT_COUNT = "com.ctc.wstx.maxElementCount";

        private static final java.lang.String P_MAX_ELEMENT_DEPTH = "com.ctc.wstx.maxElementDepth";

        private static final java.lang.String P_MAX_CHARACTERS = "com.ctc.wstx.maxCharacters";

        private static final java.lang.String P_INTERN_NSURIS = "org.codehaus.stax2.internNsUris";

        private static final java.lang.String P_RETURN_NULL_FOR_DEFAULT_NAMESPACE = "com.ctc.wstx.returnNullForDefaultNamespace";

        public Woodstox(XMLInputFactory xif) {

            super(xif);

            if (xif.isPropertySupported(P_INTERN_NSURIS)) {

                xif.setProperty(P_INTERN_NSURIS, true);

                if (LOGGER.isLoggable(Level.FINE)) {

                    LOGGER.log(Level.FINE, P_INTERN_NSURIS + " is {0}", true);

                }

            }

            if (xif.isPropertySupported(P_MAX_ATTRIBUTES_PER_ELEMENT)) {

                maxAttributesPerElement = Integer.valueOf(buildIntegerValue(

                    PROPERTY_MAX_ATTRIBUTES_PER_ELEMENT, DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT)

                );

                xif.setProperty(P_MAX_ATTRIBUTES_PER_ELEMENT, maxAttributesPerElement);

                if (LOGGER.isLoggable(Level.FINE)) {

                    LOGGER.log(Level.FINE, P_MAX_ATTRIBUTES_PER_ELEMENT + " is {0}", maxAttributesPerElement);

                }

            }

            if (xif.isPropertySupported(P_MAX_ATTRIBUTE_SIZE)) {

                maxAttributeSize = Integer.valueOf(buildIntegerValue(

                    PROPERTY_MAX_ATTRIBUTE_SIZE, DEFAULT_MAX_ATTRIBUTE_SIZE)

                );

                xif.setProperty(P_MAX_ATTRIBUTE_SIZE, maxAttributeSize);

                if (LOGGER.isLoggable(Level.FINE)) {

                    LOGGER.log(Level.FINE, P_MAX_ATTRIBUTE_SIZE + " is {0}", maxAttributeSize);

                }