/**
    * 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.core.InvalidParameterException;
  import org.figure8.join.core.Configurable;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.jencks.EndpointFactorySupport;
  import org.jencks.TargetSourceMessageListener;
  import org.springframework.aop.target.CommonsPoolTargetSource;
  import org.springframework.beans.factory.support.RootBeanDefinition;
  import org.springframework.beans.factory.support.ChildBeanDefinition;
  import org.springframework.beans.factory.support.DefaultListableBeanFactory;
  import org.springframework.beans.MutablePropertyValues;
  
  import javax.jms.MessageListener;
  import javax.resource.spi.UnavailableException;
  import javax.transaction.TransactionManager;
  import java.util.Properties;
  import java.util.List;
  /**
   * This is an implementation of JCA <code>MessageEndpointFactory</code>
   * creating MessageEndpoint from bean wrapping information on a {@link
   * JMSConsumerBean}.
   * <br/>
   * This factory takes care if consumer is thread safe or not.
   * @see javax.resource.spi.endpoint.MessageEndpointFactory
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class JMSConsumerEndpointFactory extends EndpointFactorySupport{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(JMSConsumerEndpointFactory.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The bean wrapping information on a JMSConsumerBean. */
     private JMSConsumerBeanInfo consumerInfo = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /**
      * Creates a new JMSConsumerEndpointFactory with consumer info.
      * @param consumerInfo The bean wrapping information on a JMSConsumerBean
      */
     public JMSConsumerEndpointFactory(JMSConsumerBeanInfo consumerInfo){
        this.consumerInfo = consumerInfo;
     }
  
     /**
      * Creates a new JMSConsumerEndpointFactory with consumer info
      * and a transaction manager.
      * @param consumerInfo The bean wrapping information on a JMSConsumerBean
      * @param transactionManager TransactionManager for creating inbound JCA connector
      */
     public JMSConsumerEndpointFactory(JMSConsumerBeanInfo consumerInfo, TransactionManager transactionManager){
        this.consumerInfo = consumerInfo;
        this.transactionManager = transactionManager;
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @return The bean wrapping information on a JMSConsumerBean */
     public JMSConsumerBeanInfo getConsumerInfo(){
        return consumerInfo;
     }
     /** @param consumerInfo The bean wrapping information on a JMSConsumerBean */
     public void setConsumerInfo(JMSConsumerBeanInfo consumerInfo){
        this.consumerInfo = consumerInfo;
     }
  
  
     // Implementation of EndpointFactorySupport ---------------------------------
  
     /**
      * Implementation of EndpointFactorySupport. This method deals with the
      * creation of message listener that will be used as a JCA endpoint. Depending
      * on the thread safetyness of the consumer, it may be wrapped into a pooling
      * proxy.
     * @throws UnavailableException if consumer cannot be created
     * @return The newly created message listener implementation
     */
    protected MessageListener createMessageListener() throws UnavailableException{
       // Prepare result.
       MessageListener listener = null;
       JMSConsumerBean consumer = null;
 
       try{
          // First, assume we are thread safe and assign consumer instance.
          log.info("Creating a MessageListener of class: " + consumerInfo.getConsumerBeanClass());
          consumer = consumerInfo.getJMSConsumerBean();
          listener = consumerInfo.getJMSConsumerBean();
          log.info("Name of JMSConsumerBean [" + listener + "]: " + ((JMSConsumerBean)listener).getName());
       }
       catch (InvalidParameterException e){
          log.error("Exception while creating a Messagelistener of class: " + consumerInfo.getConsumerBeanClass());
          log.error("Here's the detailed exception msg: " + e.getMessage());
          throw new UnavailableException("Cannot create a MessageListener in EndpointFactory", e);
       }
 
       // Then, if not thread safe, wrap consumer into a proxied message listener
       // that allows consumer pooling. Use Spring facilities for that.
       if (!consumerInfo.isThreadSafe()){
          log.debug("Consumer is not thread safe so wrapping it into a PoolableObjectFactory.");
          // We have to register consumer into a bean factory, ...
          DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
 
 
          //RootBeanDefinition beanDef = new RootBeanDefinition(listener.getClass(), false);
          //beanFactory.registerBeanDefinition("listener", beanDef);
 
          // This is a test on how to duplicate property values of bean...
          // If not done, pooled instances will have no property values !!!
          RootBeanDefinition beanDef = new RootBeanDefinition(consumer.getClass(), false);
          MutablePropertyValues values = new MutablePropertyValues();
          values.addPropertyValue("name", consumer.getName());
 
          // Add parameters if configurable.
          if (consumer instanceof Configurable){
             Properties parameters = new Properties();
             List consumerParameters = consumerInfo.getConsumerParameterInfos();
             for (int i=0; i<consumerParameters.size(); i++){
                JMSConsumerBeanParameterInfo parameter = (JMSConsumerBeanParameterInfo)consumerParameters.get(i);
                parameters.setProperty(parameter.getName(), parameter.getValue());
             }
             values.addPropertyValue("parameters", parameters);
          }
 
          beanDef.setPropertyValues(values);
          beanFactory.registerBeanDefinition("parent", beanDef);
          ChildBeanDefinition childDef = new ChildBeanDefinition("parent", null);
          childDef.setSingleton(false);
          System.err.println(beanDef.getPropertyValues());
          childDef.setPropertyValues(beanDef.getPropertyValues());
          beanFactory.registerBeanDefinition("listener", childDef);
 
 
          // ... initialize a target source with bean, ...
          CommonsPoolTargetSource target = new CommonsPoolTargetSource();
          target.setTargetBeanName("listener");
          target.setBeanFactory(beanFactory);
          // ... proxy with a target source that is a message listener.
          TargetSourceMessageListener proxy = new TargetSourceMessageListener();
          proxy.setTargetSource(target);
          listener = proxy;
       }
       log.info("Created listener: " + listener);
       return listener;
    }
 }