/*
    * Copyright (C) The Apache Software Foundation. All rights reserved.
    *
    * This software is published under the terms of the Apache Software License
    * version 1.1, a copy of which has been included with this distribution in
    * the LICENSE file.
    * 
    * $Id: MessengerSession.java 155459 2005-02-26 13:24:44Z dirkv $
    */
  package org.apache.commons.messenger;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.jms.Destination;
  import javax.jms.JMSException;
  import javax.jms.MessageConsumer;
  import javax.jms.MessageProducer;
  import javax.jms.Queue;
  import javax.jms.QueueRequestor;
  import javax.jms.QueueSession;
  import javax.jms.Session;
  import javax.jms.Topic;
  import javax.jms.TopicRequestor;
  import javax.jms.TopicSession;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /** <p><code>MessengerSession</code> represents all the local information for a single thread.</p>
    *
    * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
    * @version $Revision: 155459 $
    */
  public class MessengerSession {
  
      private static final Log log = LogFactory.getLog(MessengerSupport.class);
  
      /** @todo should have ack mode for sending and consuming */
  
  
      /** the JMS Session for this thread */
      private Session session;
  
      /** the JMS Listener (async subscription) Session for this thread */
      private Session listenerSession;
  
      /** the MessageConsumer for this threads reply to destination */
      private MessageConsumer replyToConsumer;
  
      /** The factory used to create each thread's JMS Session */
      private SessionFactory sessionFactory;
  
      /** An optional cache of requestors */
      private Map requestorsMap;
  
      /** The inbox which is used for the call() methods */
      private Destination replyToDestination;
  
      /** The current messenger to which I'm connected */
      private MessengerSupport messenger;
  
      /** The producer used to send messages using this session */
      private MessageProducer producer;
  
      public MessengerSession(MessengerSupport messenger, SessionFactory sessionFactory) {
          this.messenger = messenger;
          this.sessionFactory = sessionFactory;
      }
  
      public SessionFactory getSessionFactory() {
          return sessionFactory;
      }
  
      /**
       * Closes any sessions or producers open
       */
      public void close() throws JMSException {
          if (producer != null) {
              producer.close();
              producer = null;
          }
  
          if (session != null) {
              session.close();
              session = null;
          }
          if (listenerSession != null) {
              listenerSession.close();
              listenerSession = null;
          }
      }
      
      
      /** 
       * @return the JMS Session for this thread for synchronous mode 
       */
      public Session getSession() throws JMSException {
          if (session == null) {
             session = createSession();
         }
         return session;
     }
 
     /** 
      * @return the JMS Session for this thread for asynchronous mode 
      */
     public Session getListenerSession() throws JMSException {
         if (listenerSession == null) {
             listenerSession = createSession();
         }
         return listenerSession;
     }
  
     /** 
      * @return the MessageConsumer for the ReplyTo Destination for this thread
      */
     public MessageConsumer getReplyToConsumer() throws JMSException {
         return replyToConsumer;
     }
 
     public void setReplyToConsumer(MessageConsumer replyToConsumer) {
         this.replyToConsumer = replyToConsumer;
     }
 
     /**
      * @return the MessageProducer for the given destination.
      */
     public MessageProducer getMessageProducer(Destination destination) throws JMSException {
         if (producer == null) {
             producer = messenger.createMessageProducer(this, null);
         }
         return producer;
     }
 
     /** 
      * @return the reply to destination (a temporary queue) 
      * used to reply to this thread and session
      */
     protected Destination getReplyToDestination() throws JMSException {
         if (replyToDestination == null) {
             replyToDestination = createTemporaryDestination();
         }
         return replyToDestination;
     }
 
     /** 
      * Sets the reply to destination to use
      */
     protected void setReplyToDestination(Destination replyToDestination) throws JMSException {
         this.replyToDestination = replyToDestination;
     }
 
     /**
      * @return either a cached TopicRequestor or creates a new one
      */
     public TopicRequestor getTopicRequestor(TopicSession session, Topic destination) throws JMSException {
         if (messenger.isCacheRequestors()) {
             TopicRequestor requestor = (TopicRequestor) getRequestorsMap().get(destination);
             if (requestor == null) {
                 requestor = new TopicRequestor(session, destination);
                 getRequestorsMap().put(destination, requestor);
             }
             return requestor;
         }
         else {
             return new TopicRequestor(session, destination);
         }
     }
 
     /**
      * @return either a cached QueueRequestor or creates a new one
      */
     public QueueRequestor getQueueRequestor(QueueSession session, Queue destination) throws JMSException {
         if (messenger.isCacheRequestors()) {
             QueueRequestor requestor = (QueueRequestor) getRequestorsMap().get(destination);
             if (requestor == null) {
                 requestor = new QueueRequestor(session, destination);
                 getRequestorsMap().put(destination, requestor);
             }
             return requestor;
         }
         else {
             return new QueueRequestor(session, destination);
         }
     }
 
     public boolean isTopic() throws JMSException {
         return getSessionFactory().isTopic();
     }
 
 
 
 
     /** 
      * Factory method to create a new JMS Session 
      */
     protected Session createSession() throws JMSException {
         Session answer = getSessionFactory().createSession(messenger.getConnection());
         log.info("Created JMS session: " + answer);
         return answer;
     }
 
     /**
      * Factory method to create a new temporary destination
      */
     protected Destination createTemporaryDestination() throws JMSException {
         if (isTopic()) {
             TopicSession topicSession = (TopicSession) session;
             return topicSession.createTemporaryTopic();
         }
         else {
             QueueSession queueSession = (QueueSession) session;
             return queueSession.createTemporaryQueue();
         }
     }
 
     /** 
      * @return the map of requestors, indexed by destination.
      *  The Map will be lazily constructed
      */
     protected Map getRequestorsMap() {
         if (requestorsMap == null) {
             requestorsMap = new HashMap();
         }
         return requestorsMap;
     }
 }