/*
    * 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: Main.java 155459 2005-02-26 13:24:44Z dirkv $
    */
  package org.apache.commons.messagelet;
  
  import java.util.Iterator;
  
  import javax.jms.JMSException;
  import javax.servlet.ServletContext;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.commons.messagelet.model.SubscriptionDigester;
  import org.apache.commons.messagelet.model.SubscriptionList;
  import org.apache.commons.messenger.Messenger;
  import org.apache.commons.messenger.MessengerManager;
  
  /** 
   * <p><code>Main</code> is a simple command line program that will
   * create a number of subscriptions and consume messages using just regular 
   * MDO and MessageListener classes.
   *
   * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
   * @version $Revision: 155459 $
   */
  public class Main {
  
      /** Logger */
      private static final Log log = LogFactory.getLog(Main.class);
  
      /** The JMS connections */    
      private MessengerManager manager;
  
      /** The JMS Subscriptions */
      private SubscriptionList subscriptionList;
      
      /** The URI that connections are loaded from */
      private String connectionsConfig = "Messenger.xml";
      
      /** The URI where subscriptions are loaded from */
      private String subscriptionsConfig = "subscriptions.xml";
  
      /** Should we use a stopwatch to output performance metrics */
      private boolean useStopWatch = false;
  
      
      public static void main(String[] args) {
          Main main = new Main();
          if ( args.length <= 0 ) {
              System.out.println( "Usage <subscriptionConfigFile> [<connectionsConfigFile>]" );
              return;
          }
          if ( args.length > 0 ) {
              main.setSubscriptionsConfig( args[0] );
          }
          if ( args.length > 1 ) {
              main.setConnectionsConfig( args[1] );
          }
  
          try {
              main.run();
          }        
          catch (Exception e) {
              log.error( "Caught: " + e, e );
          }
      }
      
      public Main() {
      }
  
  
      /**
       * Starts all the JMS connections and consumes JMS messages, 
       * passing them onto the MessageListener and Message Driven Objects
       */
      public void run() throws Exception {
  
          // force lazy construction
          SubscriptionManager subscriber = new SubscriptionManager();
          subscriber.setMessengerManager( getMessengerManager() );
          subscriber.setSubscriptionList( createSubscriptionList() );
          subscriber.setServletContext( getServletContext() );
          
          subscriber.subscribe();
          
          // now lets start all the connections...
          for (Iterator iter = manager.getMessengerNames(); iter.hasNext(); ) {
              String name = (String) iter.next();
              Messenger messenger = manager.getMessenger( name );
              try {
                  messenger.getConnection().start();
              }
              catch (JMSException e) {
                 log.error( "Caught exception trying to start messenger: " + name + ". Exception: " + e, e );
             }
         }
         
         //waitForever();
     }
 
     
     public Messenger getMessenger(String name) throws JMSException {
         return getMessengerManager().getMessenger( name );
     }
     
     
     // Properties
     //-------------------------------------------------------------------------    
 
     public String getConnectionsConfig() {
         return connectionsConfig;
     }
     
     public void setConnectionsConfig(String connectionsConfig) {
         this.connectionsConfig = connectionsConfig;
     }
     
     public String getSubscriptionsConfig() {
         return subscriptionsConfig;
     }
     
     public void setSubscriptionsConfig(String subscriptionsConfig) {
         this.subscriptionsConfig = subscriptionsConfig;
     }
     
     public MessengerManager getMessengerManager() throws JMSException {
         if ( manager == null ) {
             manager = createMessengerManager();
             MessengerManager.setInstance( manager );
         }
         return manager;
     }
     
     public void setMessengerManager(MessengerManager manager) {
         this.manager = manager;
     }
     
     // Implementation methods
     //-------------------------------------------------------------------------    
     protected MessengerManager createMessengerManager() throws JMSException {
         String config = connectionsConfig;
         
         log.info( "Creating the JMS connections from the file: " + config );
         
         try {
             return MessengerManager.load( config );
         }
         catch (JMSException e) {
             log.error( "Could not parse Messenger connection XML deployment document for URL: " + config, e );
             
             throw new JMSException(
                 "Could not parse Messenger connection XML deployment document for URL: " + config
                 + " reason: " + e
             );
         }
     }
     
     protected SubscriptionList createSubscriptionList() throws JMSException {
         String config = subscriptionsConfig;
         
         log.info( "Loading the JMS subscriptions from: " + config );
         
         try {
             SubscriptionDigester digester = new SubscriptionDigester();
             return (SubscriptionList) digester.parse( config );
         }
         catch (Exception e) {
             log.error( "Could not parse Messenger subscription XML deployment document for URL: " + config, e );
             
             throw new JMSException(
                 "Could not parse Messenger subscription XML deployment document for URL: " + config
                 + " reason: " + e
             );
         }
     }
     
     protected ServletContext getServletContext() {
         return null;
     }
     
     /**
      * This method blocks the current thread indefinitely until the JVM is terminated.
      */
     protected void waitForever() {
         Object lock = new Object();
         synchronized (lock) {
             while (true) {
                 try {
                     lock.wait();
                 }
                 catch (Exception e) {
                     log.warn( "Main thread interupted: " + e, e );
                 }
             }
         }
     }
 }