/*** 
    * 
    * Copyright 2004 Protique Ltd
    * 
    * 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 
    * 
    * 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.codehaus.activespace.jms;
  
  import org.codehaus.activespace.Space;
  import org.codehaus.activespace.SpaceException;
  import org.codehaus.activespace.SpaceFactory;
  
  import javax.jms.Connection;
  import javax.jms.ConnectionFactory;
  import javax.jms.JMSException;
  
  /***
   * A JMS implemenation of {@link SpaceFactory} which needs to be configured with a
   * JMS connection to be usable.
   *
   * @version $Revision: 1.1.1.1 $
   */
  public class JmsSpaceFactory implements SpaceFactory {
      private Marshaller marshaller = JmsSpace.DEFAULT_MARSHALLER;
      private boolean transacted = JmsSpace.DEFAULT_TRANSACTED;
      private int deliveryMode = JmsSpace.DEFAULT_DELIVERY_MODE;
      private int priority = JmsSpace.DEFAULT_PRIORITY;
      private int acknowledgeMode = JmsSpace.DEFAULT_ACKNOWLEGE_MODE;
      private ConnectionFactory connectionFactory;
      private Connection connection;
      private int count;
      private String user;
      private String password;
  
      public JmsSpaceFactory() {
      }
  
      public JmsSpaceFactory(ConnectionFactory connectionFactory) {
          this.connectionFactory = connectionFactory;
      }
  
      public Space createSpace(String destination, int deliveryMode, String selector) throws SpaceException {
          try {
              JmsSpace answer = new JmsSpace(this, getConnection(), destination, deliveryMode, selector, transacted, getMarshaller(), deliveryMode, priority, acknowledgeMode);
              return answer;
          }
          catch (JMSException e) {
              throw new SpaceException("Could not create a JMS connection: " + e, e);
          }
      }
  
  
      // Properties
      //-------------------------------------------------------------------------
      public boolean isTransacted() {
          return transacted;
      }
  
      public void setTransacted(boolean transacted) {
          this.transacted = transacted;
      }
  
      public int getDeliveryMode() {
          return deliveryMode;
      }
  
      public void setDeliveryMode(int deliveryMode) {
          this.deliveryMode = deliveryMode;
      }
  
      public int getPriority() {
          return priority;
      }
  
      public void setPriority(int priority) {
          this.priority = priority;
      }
  
      public int getAcknowledgeMode() {
          return acknowledgeMode;
      }
  
      public void setAcknowledgeMode(int acknowledgeMode) {
          this.acknowledgeMode = acknowledgeMode;
      }
  
      public Marshaller getMarshaller() {
          return marshaller;
     }
 
     public Connection getConnection() throws JMSException, SpaceException {
         if (connection == null) {
             connection = createConnection();
             connection.start();
         }
         return connection;
     }
 
     public void setMarshaller(Marshaller marshaller) {
         this.marshaller = marshaller;
     }
 
     public void setConnection(Connection connection) {
         this.connection = connection;
     }
 
     public ConnectionFactory getConnectionFactory() throws SpaceException {
         if (connectionFactory == null) {
             try {
                 connectionFactory = createConnectionFactory();
             }
             catch (JMSException e) {
                 throw new SpaceException("Could not create a JMS ConnectionFactory: " + e, e);
             }
         }
         return connectionFactory;
     }
 
     public void setConnectionFactory(ConnectionFactory connectionFactory) {
         this.connectionFactory = connectionFactory;
     }
 
     public String getUser() {
         return user;
     }
 
     /***
      * Sets the user name used to create new JMS connections or null to not use one
      *
      * @param user
      */
     public void setUser(String user) {
         this.user = user;
     }
 
     public String getPassword() {
         return password;
     }
 
     /***
      * Sets the password to use when creating new JMS connections if a user name is specified
      * otherwise this property is ignored
      *
      * @param password
      */
     public void setPassword(String password) {
         this.password = password;
     }
 
     // Implementation methods
     //-------------------------------------------------------------------------
     protected ConnectionFactory createConnectionFactory() throws JMSException, SpaceException {
         throw new SpaceException("No JMS ConnectionFactory is configured for this SpaceFactory so cannot create a new Space");
     }
 
     protected Connection createConnection() throws SpaceException, JMSException {
         if (user != null) {
             return getConnectionFactory().createConnection(user, password);
         }
         else {
             return getConnectionFactory().createConnection();
         }
     }
 
     /***
      * Hook so that the factory knows that a space is starting
      *
      * @param space
      */
     synchronized void onSpaceStart(JmsSpace space) {
         ++count;
     }
 
     /***
      * Hook so that the factory can close down any resources
      *
      * @param space
      * @throws JMSException
      */
     synchronized void onSpaceClose(JmsSpace space) throws JMSException {
         if (--count <= 0 && connection != null) {
             try {
                 connection.close();
             }
             finally {
                 connection = null;
             }
         }
     }
 
 }