/*
 * Copyright 2002-2020 the original author or authors.
 *
 * Licensed 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
 *
 *      https://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 org.springframework.jms.connection;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.ExceptionListener;
import javax.jms.JMSContext;
import javax.jms.JMSException;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.Session;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;

/**
 * A JMS ConnectionFactory adapter that returns the same Connection
 * from all {@link #createConnection()} calls, and ignores calls to
 * {@link javax.jms.Connection#close()}. According to the JMS Connection
 * model, this is perfectly thread-safe (in contrast to e.g. JDBC). The
 * shared Connection can be automatically recovered in case of an Exception.
 *
 * <p>You can either pass in a specific JMS Connection directly or let this
 * factory lazily create a Connection via a given target ConnectionFactory.
 * This factory generally works with JMS 1.1 as well as the JMS 1.0.2 API.
 *
 * <p>Note that when using the JMS 1.0.2 API, this ConnectionFactory will switch
 * into queue/topic mode according to the JMS API methods used at runtime:
 * {@code createQueueConnection} and {@code createTopicConnection} will
 * lead to queue/topic mode, respectively; generic {@code createConnection}
 * calls will lead to a JMS 1.1 connection which is able to serve both modes.
 *
 * <p>As of Spring Framework 5, this class supports JMS 2.0 {@code JMSContext}
 * calls and therefore requires the JMS 2.0 API to be present at runtime.
 * It may nevertheless run against a JMS 1.1 driver (bound to the JMS 2.0 API)
 * as long as no actual JMS 2.0 calls are triggered by the application's setup.
 *
 * <p>Useful for testing and standalone environments in order to keep using the
 * same Connection for multiple {@link org.springframework.jms.core.JmsTemplate}
 * calls, without having a pooling ConnectionFactory underneath. This may span
 * any number of transactions, even concurrently executing transactions.
 *
 * <p>Note that Spring's message listener containers support the use of
 * a shared Connection within each listener container instance. Using
 * SingleConnectionFactory in combination only really makes sense for
 * sharing a single JMS Connection <i>across multiple listener containers</i>.
 *
 * @author Juergen Hoeller
 * @author Mark Pollack
 * @since 1.1
 * @see org.springframework.jms.core.JmsTemplate
 * @see org.springframework.jms.listener.SimpleMessageListenerContainer
 * @see org.springframework.jms.listener.DefaultMessageListenerContainer#setCacheLevel
 */
public class SingleConnectionFactory implements ConnectionFactory, QueueConnectionFactory,
                TopicConnectionFactory, ExceptionListener, InitializingBean, DisposableBean {

        protected final Log logger = LogFactory.getLog(getClass());

        @Nullable
        private ConnectionFactory targetConnectionFactory;

        @Nullable
        private String clientId;

        @Nullable
        private ExceptionListener exceptionListener;

        private boolean reconnectOnException = false;

        /** The target Connection. */
        @Nullable
        private Connection connection;

        /** A hint whether to create a queue or topic connection. */
        @Nullable
        private Boolean pubSubMode;

        /** An internal aggregator allowing for per-connection ExceptionListeners. */
        @Nullable
        private AggregatedExceptionListener aggregatedExceptionListener;

        /** Whether the shared Connection has been started. */
        private int startedCount = 0;

        /** Synchronization monitor for the shared Connection. */
        private final Object connectionMonitor = new Object();


        /**
         * Create a new SingleConnectionFactory for bean-style usage.
         * @see #setTargetConnectionFactory
         */
        public SingleConnectionFactory() {
        }

        /**
         * Create a new SingleConnectionFactory that always returns the given Connection.
         * @param targetConnection the single Connection
         */
        public SingleConnectionFactory(Connection targetConnection) {
                Assert.notNull(targetConnection, "Target Connection must not be null");
                this.connection = targetConnection;
        }

        /**
         * Create a new SingleConnectionFactory that always returns a single Connection
         * that it will lazily create via the given target ConnectionFactory.
         * @param targetConnectionFactory the target ConnectionFactory
         */
        public SingleConnectionFactory(ConnectionFactory targetConnectionFactory) {
                Assert.notNull(targetConnectionFactory, "Target ConnectionFactory must not be null");
                this.targetConnectionFactory = targetConnectionFactory;
        }


        /**
         * Set the target ConnectionFactory which will be used to lazily
         * create a single Connection.
         */
        public void setTargetConnectionFactory(@Nullable ConnectionFactory targetConnectionFactory) {
                this.targetConnectionFactory = targetConnectionFactory;
        }

        /**
         * Return the target ConnectionFactory which will be used to lazily
         * create a single Connection, if any.
         */
        @Nullable
        public ConnectionFactory getTargetConnectionFactory() {
                return this.targetConnectionFactory;
        }

        /**
         * Specify a JMS client ID for the single Connection created and exposed
         * by this ConnectionFactory.
         * <p>Note that client IDs need to be unique among all active Connections
         * of the underlying JMS provider. Furthermore, a client ID can only be
         * assigned if the original ConnectionFactory hasn't already assigned one.
         * @see javax.jms.Connection#setClientID
         * @see #setTargetConnectionFactory
         */
        public void setClientId(@Nullable String clientId) {
                this.clientId = clientId;
        }

        /**
         * Return a JMS client ID for the single Connection created and exposed
         * by this ConnectionFactory, if any.
         */
        @Nullable
        protected String getClientId() {
                return this.clientId;
        }

        /**
         * Specify an JMS ExceptionListener implementation that should be
         * registered with the single Connection created by this factory.
         * @see #setReconnectOnException
         */
        public void setExceptionListener(@Nullable ExceptionListener exceptionListener) {
                this.exceptionListener = exceptionListener;
        }

        /**
         * Return the JMS ExceptionListener implementation that should be registered
         * with the single Connection created by this factory, if any.
         */
        @Nullable
        protected ExceptionListener getExceptionListener() {
                return this.exceptionListener;
        }

        /**
         * Specify whether the single Connection should be reset (to be subsequently renewed)
         * when a JMSException is reported by the underlying Connection.
         * <p>Default is "false". Switch this to "true" to automatically trigger
         * recovery based on your JMS provider's exception notifications.
         * <p>Internally, this will lead to a special JMS ExceptionListener
         * (this SingleConnectionFactory itself) being registered with the
         * underlying Connection. This can also be combined with a
         * user-specified ExceptionListener, if desired.
         * @see #setExceptionListener
         */
        public void setReconnectOnException(boolean reconnectOnException) {
                this.reconnectOnException = reconnectOnException;
        }

        /**
         * Return whether the single Connection should be renewed when
         * a JMSException is reported by the underlying Connection.
         */
        protected boolean isReconnectOnException() {
                return this.reconnectOnException;
        }

        /**
         * Make sure a Connection or ConnectionFactory has been set.
         */
        @Override
        public void afterPropertiesSet() {
                if (this.connection == null && getTargetConnectionFactory() == null) {
                        throw new IllegalArgumentException("Target Connection or ConnectionFactory is required");
                }
        }


        @Override
        public Connection createConnection() throws JMSException {
                return getSharedConnectionProxy(getConnection());
        }

        @Override
        public Connection createConnection(String username, String password) throws JMSException {
                throw new javax.jms.IllegalStateException(
                                "SingleConnectionFactory does not support custom username and password");
        }

        @Override
        public QueueConnection createQueueConnection() throws JMSException {
                Connection con;
                synchronized (this.connectionMonitor) {
                        this.pubSubMode = Boolean.FALSE;
                        con = createConnection();
                }
                if (!(con instanceof QueueConnection)) {
                        throw new javax.jms.IllegalStateException(
                                        "This SingleConnectionFactory does not hold a QueueConnection but rather: " + con);
                }
                return ((QueueConnection) con);
        }

        @Override
        public QueueConnection createQueueConnection(String username, String password) throws JMSException {
                throw new javax.jms.IllegalStateException(
                                "SingleConnectionFactory does not support custom username and password");
        }

        @Override
        public TopicConnection createTopicConnection() throws JMSException {
                Connection con;
                synchronized (this.connectionMonitor) {
                        this.pubSubMode = Boolean.TRUE;
                        con = createConnection();
                }
                if (!(con instanceof TopicConnection)) {
                        throw new javax.jms.IllegalStateException(
                                        "This SingleConnectionFactory does not hold a TopicConnection but rather: " + con);
                }
                return ((TopicConnection) con);
        }

        @Override
        public TopicConnection createTopicConnection(String username, String password) throws JMSException {
                throw new javax.jms.IllegalStateException(
                                "SingleConnectionFactory does not support custom username and password");
        }

        @Override
        public JMSContext createContext() {
                return obtainTargetConnectionFactory().createContext();
        }

        @Override
        public JMSContext createContext(String userName, String password) {
                return obtainTargetConnectionFactory().createContext(userName, password);
        }

        @Override
        public JMSContext createContext(String userName, String password, int sessionMode) {
                return obtainTargetConnectionFactory().createContext(userName, password, sessionMode);
        }

        @Override
        public JMSContext createContext(int sessionMode) {
                return obtainTargetConnectionFactory().createContext(sessionMode);
        }

        private ConnectionFactory obtainTargetConnectionFactory() {
                ConnectionFactory target = getTargetConnectionFactory();
                Assert.state(target != null, "'targetConnectionFactory' is required");
                return target;
        }


        /**
         * Obtain an initialized shared Connection.
         * @return the Connection (never {@code null})
         * @throws javax.jms.JMSException if thrown by JMS API methods
         * @see #initConnection()
         */
        protected Connection getConnection() throws JMSException {
                synchronized (this.connectionMonitor) {
                        if (this.connection == null) {
                                initConnection();
                        }
                        return this.connection;
                }
        }

        /**
         * Initialize the underlying shared Connection.
         * <p>Closes and reinitializes the Connection if an underlying
         * Connection is present already.
         * @throws javax.jms.JMSException if thrown by JMS API methods
         * @see #prepareConnection
         */
        public void initConnection() throws JMSException {
                if (getTargetConnectionFactory() == null) {
                        throw new IllegalStateException(
                                        "'targetConnectionFactory' is required for lazily initializing a Connection");
                }
                synchronized (this.connectionMonitor) {
                        if (this.connection != null) {
                                closeConnection(this.connection);
                        }
                        this.connection = doCreateConnection();
                        prepareConnection(this.connection);
                        if (this.startedCount > 0) {
                                this.connection.start();
                        }
                        if (logger.isDebugEnabled()) {
                                logger.debug("Established shared JMS Connection: " + this.connection);
                        }
                }
        }

        /**
         * Exception listener callback that renews the underlying single Connection.
         * @see #resetConnection()
         */
        @Override
        public void onException(JMSException ex) {
                logger.info("Encountered a JMSException - resetting the underlying JMS Connection", ex);
                resetConnection();
        }

        /**
         * Close the underlying shared connection.
         * The provider of this ConnectionFactory needs to care for proper shutdown.
         * <p>As this bean implements DisposableBean, a bean factory will
         * automatically invoke this on destruction of its cached singletons.
         * @see #resetConnection()
         */
        @Override
        public void destroy() {
                resetConnection();
        }

        /**
         * Reset the underlying shared Connection, to be reinitialized on next access.
         * @see #closeConnection
         */
        public void resetConnection() {
                synchronized (this.connectionMonitor) {
                        if (this.connection != null) {
                                closeConnection(this.connection);
                        }
                        this.connection = null;
                }
        }

        /**
         * Create a JMS Connection via this template's ConnectionFactory.
         * @return the new JMS Connection
         * @throws javax.jms.JMSException if thrown by JMS API methods
         */
        protected Connection doCreateConnection() throws JMSException {
                ConnectionFactory cf = getTargetConnectionFactory();
                if (Boolean.FALSE.equals(this.pubSubMode) && cf instanceof QueueConnectionFactory) {
                        return ((QueueConnectionFactory) cf).createQueueConnection();
                }
                else if (Boolean.TRUE.equals(this.pubSubMode) && cf instanceof TopicConnectionFactory) {
                        return ((TopicConnectionFactory) cf).createTopicConnection();
                }
                else {
                        return obtainTargetConnectionFactory().createConnection();
                }
        }

        /**
         * Prepare the given Connection before it is exposed.
         * <p>The default implementation applies ExceptionListener and client id.
         * Can be overridden in subclasses.
         * @param con the Connection to prepare
         * @throws JMSException if thrown by JMS API methods
         * @see #setExceptionListener
         * @see #setReconnectOnException
         */
        protected void prepareConnection(Connection con) throws JMSException {
                if (getClientId() != null) {
                        con.setClientID(getClientId());
                }
                if (this.aggregatedExceptionListener != null) {
                        con.setExceptionListener(this.aggregatedExceptionListener);
                }
                else if (getExceptionListener() != null || isReconnectOnException()) {
                        ExceptionListener listenerToUse = getExceptionListener();
                        if (isReconnectOnException()) {
                                this.aggregatedExceptionListener = new AggregatedExceptionListener();
                                this.aggregatedExceptionListener.delegates.add(this);
                                if (listenerToUse != null) {
                                        this.aggregatedExceptionListener.delegates.add(listenerToUse);
                                }
                                listenerToUse = this.aggregatedExceptionListener;
                        }
                        con.setExceptionListener(listenerToUse);
                }
        }

        /**
         * Template method for obtaining a (potentially cached) Session.
         * <p>The default implementation always returns {@code null}.
         * Subclasses may override this for exposing specific Session handles,
         * possibly delegating to {@link #createSession} for the creation of raw
         * Session objects that will then get wrapped and returned from here.
         * @param con the JMS Connection to operate on
         * @param mode the Session acknowledgement mode
         * ({@code Session.TRANSACTED} or one of the common modes)
         * @return the Session to use, or {@code null} to indicate
         * creation of a raw standard Session
         * @throws JMSException if thrown by the JMS API
         */
        @Nullable
        protected Session getSession(Connection con, Integer mode) throws JMSException {
                return null;
        }

        /**
         * Create a default Session for this ConnectionFactory,
         * adapting to JMS 1.0.2 style queue/topic mode if necessary.
         * @param con the JMS Connection to operate on
         * @param mode the Session acknowledgement mode
         * ({@code Session.TRANSACTED} or one of the common modes)
         * @return the newly created Session
         * @throws JMSException if thrown by the JMS API
         */
        protected Session createSession(Connection con, Integer mode) throws JMSException {
                // Determine JMS API arguments...
                boolean transacted = (mode == Session.SESSION_TRANSACTED);
                int ackMode = (transacted ? Session.AUTO_ACKNOWLEDGE : mode);
                // Now actually call the appropriate JMS factory method...
                if (Boolean.FALSE.equals(this.pubSubMode) && con instanceof QueueConnection) {
                        return ((QueueConnection) con).createQueueSession(transacted, ackMode);
                }
                else if (Boolean.TRUE.equals(this.pubSubMode) && con instanceof TopicConnection) {
                        return ((TopicConnection) con).createTopicSession(transacted, ackMode);
                }
                else {
                        return con.createSession(transacted, ackMode);
                }
        }

        /**
         * Close the given Connection.
         * @param con the Connection to close
         */
        protected void closeConnection(Connection con) {
                if (logger.isDebugEnabled()) {
                        logger.debug("Closing shared JMS Connection: " + con);
                }
                try {
                        try {
                                if (this.startedCount > 0) {
                                        con.stop();
                                }
                        }
                        finally {
                                con.close();
                        }
                }
                catch (javax.jms.IllegalStateException ex) {
                        logger.debug("Ignoring Connection state exception - assuming already closed: " + ex);
                }
                catch (Throwable ex) {
                        logger.warn("Could not close shared JMS Connection", ex);
                }
        }

        /**
         * Wrap the given Connection with a proxy that delegates every method call to it
         * but suppresses close calls. This is useful for allowing application code to
         * handle a special framework Connection just like an ordinary Connection from a
         * JMS ConnectionFactory.
         * @param target the original Connection to wrap
         * @return the wrapped Connection
         */
        protected Connection getSharedConnectionProxy(Connection target) {
                List<Class<?>> classes = new ArrayList<>(3);
                classes.add(Connection.class);
                if (target instanceof QueueConnection) {
                        classes.add(QueueConnection.class);
                }
                if (target instanceof TopicConnection) {
                        classes.add(TopicConnection.class);
                }
                return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(),
                                ClassUtils.toClassArray(classes), new SharedConnectionInvocationHandler());
        }


        /**
         * Invocation handler for a cached JMS Connection proxy.
         */
        private class SharedConnectionInvocationHandler implements InvocationHandler {

                @Nullable
                private ExceptionListener localExceptionListener;

                private boolean locallyStarted = false;

                @Override
                @Nullable
                public Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
                        if (method.getName().equals("equals") && args != null) {
                                Object other = args[0];
                                if (proxy == other) {
                                        return true;
                                }
                                if (other == null || !Proxy.isProxyClass(other.getClass())) {
                                        return false;
                                }
                                InvocationHandler otherHandler = Proxy.getInvocationHandler(other);
                                return (otherHandler instanceof SharedConnectionInvocationHandler &&
                                                factory() == ((SharedConnectionInvocationHandler) otherHandler).factory());
                        }
                        else if (method.getName().equals("hashCode")) {
                                // Use hashCode of containing SingleConnectionFactory.
                                return System.identityHashCode(factory());
                        }
                        else if (method.getName().equals("toString")) {
                                return "Shared JMS Connection: " + getConnection();
                        }
                        else if (method.getName().equals("setClientID") && args != null) {
                                // Handle setClientID method: throw exception if not compatible.
                                String currentClientId = getConnection().getClientID();
                                if (currentClientId != null && currentClientId.equals(args[0])) {
                                        return null;
                                }
                                else {
                                        throw new javax.jms.IllegalStateException(
                                                        "setClientID call not supported on proxy for shared Connection. " +
                                                        "Set the 'clientId' property on the SingleConnectionFactory instead.");
                                }
                        }
                        else if (method.getName().equals("setExceptionListener") && args != null) {
                                // Handle setExceptionListener method: add to the chain.
                                synchronized (connectionMonitor) {
                                        if (aggregatedExceptionListener != null) {
                                                ExceptionListener listener = (ExceptionListener) args[0];
                                                if (listener != this.localExceptionListener) {
                                                        if (this.localExceptionListener != null) {
                                                                aggregatedExceptionListener.delegates.remove(this.localExceptionListener);
                                                        }
                                                        if (listener != null) {
                                                                aggregatedExceptionListener.delegates.add(listener);
                                                        }
                                                        this.localExceptionListener = listener;
                                                }
                                                return null;
                                        }
                                        else {
                                                throw new javax.jms.IllegalStateException(
                                                                "setExceptionListener call not supported on proxy for shared Connection. " +
                                                                "Set the 'exceptionListener' property on the SingleConnectionFactory instead. " +
                                                                "Alternatively, activate SingleConnectionFactory's 'reconnectOnException' feature, " +
                                                                "which will allow for registering further ExceptionListeners to the recovery chain.");
                                        }
                                }
                        }
                        else if (method.getName().equals("getExceptionListener")) {
                                synchronized (connectionMonitor) {
                                        if (this.localExceptionListener != null) {
                                                return this.localExceptionListener;
                                        }
                                        else {
                                                return getExceptionListener();
                                        }
                                }
                        }
                        else if (method.getName().equals("start")) {
                                localStart();
                                return null;
                        }
                        else if (method.getName().equals("stop")) {
                                localStop();
                                return null;
                        }
                        else if (method.getName().equals("close")) {
                                localStop();
                                synchronized (connectionMonitor) {
                                        if (this.localExceptionListener != null) {
                                                if (aggregatedExceptionListener != null) {
                                                        aggregatedExceptionListener.delegates.remove(this.localExceptionListener);
                                                }
                                                this.localExceptionListener = null;
                                        }
                                }
                                return null;
                        }
                        else if (method.getName().equals("createSession") || method.getName().equals("createQueueSession") ||
                                        method.getName().equals("createTopicSession")) {
                                // Default: JMS 2.0 createSession() method
                                Integer mode = Session.AUTO_ACKNOWLEDGE;
                                if (args != null) {
                                        if (args.length == 1) {
                                                // JMS 2.0 createSession(int) method
                                                mode = (Integer) args[0];
                                        }
                                        else if (args.length == 2) {
                                                // JMS 1.1 createSession(boolean, int) method
                                                boolean transacted = (Boolean) args[0];
                                                Integer ackMode = (Integer) args[1];
                                                mode = (transacted ? Session.SESSION_TRANSACTED : ackMode);
                                        }
                                }
                                Session session = getSession(getConnection(), mode);
                                if (session != null) {
                                        if (!method.getReturnType().isInstance(session)) {
                                                String msg = "JMS Session does not implement specific domain: " + session;
                                                try {
                                                        session.close();
                                                }
                                                catch (Throwable ex) {
                                                        logger.trace("Failed to close newly obtained JMS Session", ex);
                                                }
                                                throw new javax.jms.IllegalStateException(msg);
                                        }
                                        return session;
                                }
                        }
                        try {
                                return method.invoke(getConnection(), args);
                        }
                        catch (InvocationTargetException ex) {
                                throw ex.getTargetException();
                        }
                }

                private void localStart() throws JMSException {
                        synchronized (connectionMonitor) {
                                if (!this.locallyStarted) {
                                        this.locallyStarted = true;
                                        if (startedCount == 0 && connection != null) {
                                                connection.start();
                                        }
                                        startedCount++;
                                }
                        }
                }

                private void localStop() throws JMSException {
                        synchronized (connectionMonitor) {
                                if (this.locallyStarted) {
                                        this.locallyStarted = false;
                                        if (startedCount == 1 && connection != null) {
                                                connection.stop();
                                        }
                                        if (startedCount > 0) {
                                                startedCount--;
                                        }
                                }
                        }
                }

                private SingleConnectionFactory factory() {
                        return SingleConnectionFactory.this;
                }
        }


        /**
         * Internal aggregated ExceptionListener for handling the internal
         * recovery listener in combination with user-specified listeners.
         */
        private class AggregatedExceptionListener implements ExceptionListener {

                final Set<ExceptionListener> delegates = new LinkedHashSet<>(2);

                @Override
                public void onException(JMSException ex) {
                        // Iterate over temporary copy in order to avoid ConcurrentModificationException,
                        // since listener invocations may in turn trigger registration of listeners...
                        Set<ExceptionListener> copy;
                        synchronized (connectionMonitor) {
                                copy = new LinkedHashSet<>(this.delegates);
                        }
                        for (ExceptionListener listener : copy) {
                                listener.onException(ex);
                        }
                }
        }

}