/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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.opensource.org/licenses/gpl-license.php
    *
   * This program 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 for more details.
   */
  package org.figure8.join.core.messaging;
  
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.springframework.beans.factory.DisposableBean;
  import org.springframework.jms.core.support.JmsGatewaySupport;
  
  import javax.jms.Session;
  import javax.jms.Connection;
  import javax.jms.Destination;
  import javax.jms.JMSException;
  import javax.jms.MessageConsumer;
  import javax.jms.ConnectionFactory;
  /**
   * This is a base class for JMS messages consumer implementations, based on Spring
   * JMS templates. This class defines lifecyle methods (<code>start()</code> and
   * <code>stop()</code>) that deals by connecting/deconnecting to JMS provider and
   * listened destination.
   * <br/>
   * Subclasses should only have to implement the <code>processMessage()</code>
   * method where real work has to be done. This last method should not throw any
   * exception. This means that implementation should handle every errors. 
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class JMSConsumerBeanSpringWrapper extends JmsGatewaySupport
          implements DisposableBean{
  
     // Static -------------------------------------------------------------------
  
     /** Commons logger. */
     protected static Log log = LogUtil.getLog(JMSConsumerBeanSpringWrapper.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The message selector when listening to messages */
     private String selector;
     /** The JMS destination on which to consume messages */
     private Destination destination;
  
     /** Created session for listening to messages */
     private Session session;
     /** Created connnection for listening to messages */
     private Connection connection;
     /** Created consumer for listening to messages */
     private MessageConsumer consumer;
  
     /** Wrapped JMSConsumerBean instance */
     private JMSConsumerBean consumerBean;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Default constructor. */
     public JMSConsumerBeanSpringWrapper(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @return Message selector expression used when listening to messages */
     public String getSelector(){
        return selector;
     }
     /** @param selector Message selector expression to use for filtering messages */
     public void setSelector(String selector){
        this.selector = selector;
     }
  
     /** @return JMS destination whose messages are consumed by this object */
     public Destination getDestination(){
        return destination;
     }
     /** @param destination JMS destination to consume messages for */
     public void setDestination(Destination destination){
        this.destination = destination;
     }
  
     /** @return */
     public JMSConsumerBean getConsumerBean(){
        return consumerBean;
     }
     /** @param consumerBean */
    public void setConsumerBean(JMSConsumerBean consumerBean){
       this.consumerBean = consumerBean;
    }
 
    /**
     * Lifecycle method. This method is called after bean properties intilization.
     * It is responsible for connecting to the JMS provider using the connection
     * factory injected and register the current bean as a message listener for
     * the specified JMS destination.
     * @throws JMSException if connection to provider or registration as a listener
     * is not possible
     */
    public void start() throws JMSException{
       log.info("Start method called on consumer. Trying to connect JMS provider...");
       try{
          // Let connect to JMS provider.
          ConnectionFactory factory = getConnectionFactory();
          connection = factory.createConnection();
          connection.start();
          log.info("Connection is started. Trying to register as a message listener...");
          // Create a session and a register this as a listener for consumer.
          session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
          consumer = session.createConsumer(destination, selector, false);
          consumer.setMessageListener(consumerBean);
          log.info("Start listening messages with selector: " + selector);
       }
       catch (JMSException e){
          // Log error and propagates.
          log.error("Caught a JMSException when trying initialize JMSConsumerBeanSpringWrapper", e);
          throw e;
       }
    }
 
    /**
     * Lifecycle method. This method is called on destruction of this beans. It
     * is responsible for closing and releasing all the resources acquired for
     * connection and registration as a listener (MessageConsumer, Session and
     * Connection)
     * @throws JMSException if closing a resource is not possible
     */
    public void stop() throws JMSException{
       log.info("Stop method called con consumer. Trying to close connected resources...");
       // Close consumer.
       if (consumer != null)
          consumer.close();
       // Then, close session.
       if (session != null)
          session.close();
       // Finally, close connection.
       if (connection != null)
          connection.close();
    }
 
 
    // Implementation of DisposableBean -----------------------------------------
 
    /**
     * Invoked by a BeanFactory on destruction of a singleton.
     * @throws Exception in case of shutdown errors.
     */
    public void destroy() throws Exception{
       log.debug("destroy() called on message consumer. Calling stop() method.");
       consumerBean.stop();
       stop();
    }
 
 
    // Override of JmsGatewaySupport --------------------------------------------
 
    /**
     * Gets called after population of this instance's bean properties, just call
     * <code>start()</code> method. Convenience method for testing with Spring.
     * @throws Exception if initialization fails
     */
    protected void initGateway() throws Exception{
       if (consumerBean == null)
          throw new IllegalArgumentException("consumerBean is a required property");
       log.debug("initGateway() called on message consumer. Calling start() method");
       start();
    }
 }