/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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
 *
 *   http://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.apache.qpid.ra;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;

import javax.jms.Connection;
import javax.jms.ExceptionListener;
import javax.jms.JMSException;
import javax.jms.QueueConnection;
import javax.jms.ResourceAllocationException;
import javax.jms.Session;
import javax.jms.TopicConnection;
import javax.jms.XAConnection;
import javax.jms.XAQueueConnection;
import javax.jms.XASession;
import javax.jms.XATopicConnection;
import javax.resource.ResourceException;
import javax.resource.spi.ConnectionEvent;
import javax.resource.spi.ConnectionEventListener;
import javax.resource.spi.ConnectionRequestInfo;
import javax.resource.spi.IllegalStateException;
import javax.resource.spi.LocalTransaction;
import javax.resource.spi.ManagedConnection;
import javax.resource.spi.ManagedConnectionMetaData;
import javax.resource.spi.SecurityException;
import javax.security.auth.Subject;
import javax.transaction.Status;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import javax.transaction.xa.XAResource;

import org.apache.qpid.client.Closeable;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The managed connection
 *
 */
public class QpidRAManagedConnection implements ManagedConnection, ExceptionListener
{
   /** The logger */
   private static final Logger _log = LoggerFactory.getLogger(QpidRAManagedConnection.class);

   /** The managed connection factory */
   private final QpidRAManagedConnectionFactory _mcf;

   /** The connection request information */
   private final QpidRAConnectionRequestInfo _cri;

   /** The user name */
   private final String _userName;

   /** The password */
   private final String _password;

   /** Has the connection been destroyed */
   private final AtomicBoolean _isDestroyed = new AtomicBoolean(false);

   /** Event listeners */
   private final List<ConnectionEventListener> _eventListeners;

   /** Handles */
   private final Set<QpidRASessionImpl> _handles;

   /** Lock */
   private ReentrantLock _lock = new ReentrantLock();

   // Physical JMS connection stuff
   private Connection _connection;

   private XASession _xaSession;

   private XAResource _xaResource;

   private Session _session;

   private final TransactionManager _tm;

   private boolean _inManagedTx;

   /**
    * Constructor
    * @param mcf The managed connection factory
    * @param cri The connection request information
    * @param userName The user name
    * @param password The password
    */
   public QpidRAManagedConnection(final QpidRAManagedConnectionFactory mcf,
                                     final QpidRAConnectionRequestInfo cri,
                                     final TransactionManager tm,
                                     final String userName,
                                     final String password) throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("constructor(" + mcf + ", " + cri + ", " + userName + ", ****)");
      }

      this._mcf = mcf;
      this._cri = cri;
      this._tm = tm;
      this._userName = userName;
      this._password = password;
      _eventListeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>());
      _handles = Collections.synchronizedSet(new HashSet<QpidRASessionImpl>());

      try
      {
         setup();
      }
      catch (Throwable t)
      {
         try
         {
            destroy();
         }
         catch (Throwable ignored)
         {
         }
         throw new ResourceException("Error during setup", t);
      }
   }

   /**
    * Get a connection
    * @param subject The security subject
    * @param cxRequestInfo The request info
    * @return The connection
    * @exception ResourceException Thrown if an error occurs
    */
   public synchronized Object getConnection(final Subject subject, final ConnectionRequestInfo cxRequestInfo) throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getConnection(" + subject + ", " + cxRequestInfo + ")");
      }

      // Check user first
      QpidRACredential credential = QpidRACredential.getCredential(_mcf, subject, cxRequestInfo);

      // Null users are allowed!
      if (_userName != null && !_userName.equals(credential.getUserName()))
      {
         throw new SecurityException("Password credentials not the same, reauthentication not allowed");
      }

      if (_userName == null && credential.getUserName() != null)
      {
         throw new SecurityException("Password credentials not the same, reauthentication not allowed");
      }

      if (_isDestroyed.get())
      {
         throw new IllegalStateException("The managed connection is already destroyed");
      }

      QpidRASessionImpl session = new QpidRASessionImpl(this, (QpidRAConnectionRequestInfo)cxRequestInfo);
      _handles.add(session);
      return session;
   }

   /**
    * Destroy all handles.
    * @exception ResourceException Failed to close one or more handles.
    */
   private void destroyHandles() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("destroyHandles()");
      }

      try
      {
         if (_connection != null)
         {
            _connection.stop();
         }
      }
      catch (Throwable t)
      {
         _log.trace("Ignored error stopping connection", t);
      }

      for (QpidRASessionImpl session : _handles)
      {
         session.destroy();
      }

      _handles.clear();
   }

   /**
    * Destroy the physical connection.
    * @exception ResourceException Could not property close the session and connection.
    */
   public void destroy() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("destroy()");
      }

      if (_isDestroyed.get() ||  _connection == null)
      {
         return;
      }

      _isDestroyed.set(true);

      try
      {
         _connection.setExceptionListener(null);
      }
      catch (JMSException e)
      {
         _log.debug("Error unsetting the exception listener " + this, e);
      }

      destroyHandles();

      try
      {
         try
         {
            if (_xaSession != null)
            {
               _xaSession.close();
            }
         }
         catch (JMSException e)
         {
            _log.debug("Error closing XASession " + this, e);
         }

         try
         {
             if(_session != null)
             {
                 _session.close();
             }

         }
         catch(JMSException e)
         {
             _log.error("Error closing Session " + this, e);
         }

         if (_connection != null)
         {
            _connection.close();
         }
      }
      catch (Throwable e)
      {
         throw new ResourceException("Could not properly close the session and connection", e);
      }
   }

   /**
    * Cleanup
    * @exception ResourceException Thrown if an error occurs
    */
   public void cleanup() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("cleanup()");
      }

      if (_isDestroyed.get())
      {
         throw new IllegalStateException("ManagedConnection already destroyed");
      }

      destroyHandles();

      _inManagedTx = false;

      // I'm recreating the lock object when we return to the pool
      // because it looks too nasty to expect the connection handle
      // to unlock properly in certain race conditions
      // where the dissociation of the managed connection is "random".
      _lock = new ReentrantLock();
   }

   /**
    * Move a handler from one mc to this one.
    * @param obj An object of type QpidRASession.
    * @throws ResourceException Failed to associate connection.
    * @throws IllegalStateException ManagedConnection in an illegal state.
    */
   public void associateConnection(final Object obj) throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("associateConnection(" + obj + ")");
      }

      if (!_isDestroyed.get() && obj instanceof QpidRASessionImpl)
      {
         QpidRASessionImpl h = (QpidRASessionImpl)obj;
         h.setManagedConnection(this);
         _handles.add(h);
      }
      else
      {
         throw new IllegalStateException("ManagedConnection in an illegal state");
      }
   }

   public void checkTransactionActive() throws JMSException
   {
      // don't bother looking at the transaction if there's an active XID
      if (!_inManagedTx && _tm != null)
      {
         try
         {
            Transaction tx = _tm.getTransaction();
            if (tx != null)
            {
               int status = tx.getStatus();
               // Only allow states that will actually succeed
               if (status != Status.STATUS_ACTIVE && status != Status.STATUS_PREPARING &&
                   status != Status.STATUS_PREPARED &&
                   status != Status.STATUS_COMMITTING)
               {
                  throw new javax.jms.IllegalStateException("Transaction " + tx + " not active");
               }
            }
         }
         catch (SystemException e)
         {
            JMSException jmsE = new javax.jms.IllegalStateException("Unexpected exception on the Transaction ManagerTransaction");
            jmsE.initCause(e);
            throw jmsE;
         }
      }
   }


   /**
    * Aqquire a lock on the managed connection
    */
   protected void lock()
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("lock()");
      }

      _lock.lock();
   }

   /**
    * Aqquire a lock on the managed connection within the specified period
    * @exception JMSException Thrown if an error occurs
    */
   protected void tryLock() throws JMSException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("tryLock()");
      }

      Integer tryLock = _mcf.getUseTryLock();
      if (tryLock == null || tryLock.intValue() <= 0)
      {
         lock();
         return;
      }
      try
      {
         if (_lock.tryLock(tryLock.intValue(), TimeUnit.SECONDS) == false)
         {
            throw new ResourceAllocationException("Unable to obtain lock in " + tryLock + " seconds: " + this);
         }
      }
      catch (InterruptedException e)
      {
         throw new ResourceAllocationException("Interrupted attempting lock: " + this);
      }
   }

   /**
    * Unlock the managed connection
    */
   protected void unlock()
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("unlock()");
      }

      if (_lock.isHeldByCurrentThread())
      {
         _lock.unlock();
      }
   }

   /**
    * Add a connection event listener.
    * @param l The connection event listener to be added.
    */
   public void addConnectionEventListener(final ConnectionEventListener l)
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("addConnectionEventListener(" + l + ")");
      }

      _eventListeners.add(l);
   }

   /**
    * Remove a connection event listener.
    * @param l The connection event listener to be removed.
    */
   public void removeConnectionEventListener(final ConnectionEventListener l)
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("removeConnectionEventListener(" + l + ")");
      }

      _eventListeners.remove(l);
   }

   /**
    * Get the XAResource for the connection.
    * @return The XAResource for the connection.
    * @exception ResourceException XA transaction not supported
    */
   public XAResource getXAResource() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getXAResource()");
      }

      //
      // Spec says a mc must allways return the same XA resource,
      // so we cache it.
      //
      if (_xaResource == null)
      {
            _xaResource = new QpidRAXAResource(this, _xaSession.getXAResource());
      }

      if (_log.isTraceEnabled())
      {
         _log.trace("XAResource=" + _xaResource);
      }

      return _xaResource;
   }

   /**
    * Get the location transaction for the connection.
    * @return The local transaction for the connection.
    * @exception ResourceException Thrown if operation fails.
    */
   public LocalTransaction getLocalTransaction() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getLocalTransaction()");
      }

      LocalTransaction tx = new QpidRALocalTransaction(this);

      if (_log.isTraceEnabled())
      {
         _log.trace("LocalTransaction=" + tx);
      }

      return tx;
   }

   /**
    * Get the meta data for the connection.
    * @return The meta data for the connection.
    * @exception ResourceException Thrown if the operation fails.
    * @exception IllegalStateException Thrown if the managed connection already is destroyed.
    */
   public ManagedConnectionMetaData getMetaData() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getMetaData()");
      }

      if (_isDestroyed.get())
      {
         throw new IllegalStateException("The managed connection is already destroyed");
      }

      return new QpidRAMetaData(this);
   }

   /**
    * Set the log writer -- NOT SUPPORTED
    * @param out The log writer
    * @exception ResourceException If operation fails
    */
   public void setLogWriter(final PrintWriter out) throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("setLogWriter(" + out + ")");
      }
   }

   /**
    * Get the log writer -- NOT SUPPORTED
    * @return Always null
    * @exception ResourceException If operation fails
    */
   public PrintWriter getLogWriter() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getLogWriter()");
      }

      return null;
   }

   /**
    * Notifies user of a JMS exception.
    * @param exception The JMS exception
    */
   public void onException(final JMSException exception)
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("onException(" + exception + ")");
      }

      if (_isDestroyed.get())
      {
         if (_log.isTraceEnabled())
         {
            _log.trace("Ignoring error on already destroyed connection " + this, exception);
         }
         return;
      }

      _log.warn("Handling JMS exception failure: " + this, exception);

      try
      {
         _connection.setExceptionListener(null);
      }
      catch (JMSException e)
      {
         _log.debug("Unable to unset exception listener", e);
      }

      ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, exception);
      sendEvent(event);
   }

   /**
    * Get the session for this connection.
    * @return The session
    * @throws JMSException
    */
   protected Session getSession() throws JMSException
   {
      if(_xaSession != null && !_mcf.getUseLocalTx() && _inManagedTx)
      {
          if (_log.isTraceEnabled())
          {
              _log.trace("getSession() -> XA session " + Util.asString(_xaSession));
          }

          return _xaSession;
      }
      else
      {
          if (_log.isTraceEnabled())
          {
              _log.trace("getSession() -> session " + Util.asString(_session));
          }

          return _session;
      }
   }

   /**
    * Send an event.
    * @param event The event to send.
    */
   protected void sendEvent(final ConnectionEvent event)
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("sendEvent(" + event + ")");
      }

      int type = event.getId();

      // convert to an array to avoid concurrent modification exceptions
      ConnectionEventListener[] list = _eventListeners.toArray(new ConnectionEventListener[_eventListeners.size()]);

      for (ConnectionEventListener l : list)
      {
         switch (type)
         {
            case ConnectionEvent.CONNECTION_CLOSED:
               l.connectionClosed(event);
               break;

            case ConnectionEvent.LOCAL_TRANSACTION_STARTED:
               l.localTransactionStarted(event);
               break;

            case ConnectionEvent.LOCAL_TRANSACTION_COMMITTED:
               l.localTransactionCommitted(event);
               break;

            case ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK:
               l.localTransactionRolledback(event);
               break;

            case ConnectionEvent.CONNECTION_ERROR_OCCURRED:
               l.connectionErrorOccurred(event);
               break;

            default:
               throw new IllegalArgumentException("Illegal eventType: " + type);
         }
      }
   }

   /**
    * Remove a handle from the handle map.
    * @param handle The handle to remove.
    */
   protected void removeHandle(final QpidRASessionImpl handle)
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("removeHandle(" + handle + ")");
      }

      _handles.remove(handle);
   }

   /**
    * Get the request info for this connection.
    * @return The connection request info for this connection.
    */
   protected QpidRAConnectionRequestInfo getCRI()
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getCRI()");
      }

      return _cri;
   }

   /**
    * Get the connection factory for this connection.
    * @return The connection factory for this connection.
    */
   protected QpidRAManagedConnectionFactory getManagedConnectionFactory()
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getManagedConnectionFactory()");
      }

      return _mcf;
   }

   /**
    * Start the connection
    * @exception JMSException Thrown if the connection cant be started
    */
   void start() throws JMSException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("start()");
      }

      if (_connection != null)
      {
         _connection.start();
      }
   }

   /**
    * Stop the connection
    * @exception JMSException Thrown if the connection cant be stopped
    */
   void stop() throws JMSException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("stop()");
      }

      if (_connection != null)
      {
         _connection.stop();
      }
   }

   /**
    * Get the user name
    * @return The user name
    */
   protected String getUserName()
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("getUserName()");
      }

      return _userName;
   }

   /**
    * Setup the connection.
    * @exception ResourceException Thrown if a connection couldnt be created
    */
   private void setup() throws ResourceException
   {
      if (_log.isTraceEnabled())
      {
         _log.trace("setup()");
      }

      try
      {
         boolean transacted = _cri.isTransacted() || _mcf.getUseLocalTx();
         int acknowledgeMode =  (transacted) ? Session.SESSION_TRANSACTED : _cri.getAcknowledgeMode();

         if (_cri.getType() == QpidRAConnectionFactory.TOPIC_CONNECTION)
         {
            if (_userName != null && _password != null)
            {
                _connection = _mcf.getCleanAMQConnectionFactory().createXATopicConnection(_userName, _password);
            }
            else
            {
                _connection = _mcf.getDefaultAMQConnectionFactory().createXATopicConnection();
            }

            _xaSession = ((XATopicConnection)_connection).createXATopicSession();
            _session =  ((TopicConnection)_connection).createTopicSession(transacted, acknowledgeMode);

         }
         else if (_cri.getType() == QpidRAConnectionFactory.QUEUE_CONNECTION)
         {
            if (_userName != null && _password != null)
            {
                _connection = _mcf.getCleanAMQConnectionFactory().createXAQueueConnection(_userName, _password);
            }
            else
            {
                _connection = _mcf.getDefaultAMQConnectionFactory().createXAQueueConnection();
            }

            _xaSession = ((XAQueueConnection)_connection).createXAQueueSession();
            _session =  ((QueueConnection)_connection).createQueueSession(transacted, acknowledgeMode);

         }
         else
         {
            if (_userName != null && _password != null)
            {
                _connection = _mcf.getCleanAMQConnectionFactory().createXAConnection(_userName, _password);
            }
            else
            {
                _connection = _mcf.getDefaultAMQConnectionFactory().createXAConnection();
            }
            _xaSession = ((XAConnection)_connection).createXASession();
            _session =  _connection.createSession(transacted, acknowledgeMode);
         }

        _connection.setExceptionListener(this);

      }
      catch (JMSException je)
      {
         _log.error(je.getMessage(), je);
         throw new ResourceException(je.getMessage(), je);
      }
   }

   protected void setInManagedTx(boolean inManagedTx)
   {
      this._inManagedTx = inManagedTx;
   }

   public boolean isConnectionClosed()
   {
       Closeable c = (Closeable)_connection;
       return (c == null || c.isClosed() || c.isClosing());
   }
}