/*
    * 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: ConsumerTask.java 155459 2005-02-26 13:24:44Z dirkv $
    */
  package org.apache.commons.messenger.task;
  
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  
  import javax.jms.Destination;
  import javax.jms.JMSException;
  import javax.jms.Message;
  import javax.jms.TextMessage;
  
  import org.apache.commons.messenger.Messenger;
  import org.apache.commons.messenger.MessengerManager;
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.Task;
  
  /** 
   * <p><code>ConsumerTask</code> is an Ant task which will 
   * publish all of the given text files as a JMS Text Message
   * using a given JMS Connection (Messenger) and a Destination
   *
   * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
   * @version $Revision: 155459 $
   */
  public class ConsumerTask extends Task {
  
      private Messenger messenger;
      private String messengerName;
      private Destination destination;
      private String subject;
      private MessengerManager messengerManager;    
  
      /** the number of messages to receive */
      private int count;
  
      /** the output directory */
      private File dir = new File(".");    
      
      // Properties
      //-------------------------------------------------------------------------
      
  
      /** 
       * Sets the output directory 
       */
      public void setDir(File dir) {
          this.dir = dir;
      }
  
      public Messenger getMessenger() throws JMSException {
          if ( messenger == null ) {
              messenger = getMessengerManager().getMessenger( getMessengerName() );
          }
          return messenger;
      }
      
      /** Sets the Messenger to be used */
      public void setMessenger(Messenger messenger) {
          this.messenger = messenger;
      }
      
      /** Getter for property messengerName.
       * @return Value of property messengerName.
       */
      public String getMessengerName() {
          return messengerName;
      }
  
      /** Setter for property messengerName.
       * @param messengerName New value of property messengerName.
       */
      public void setMessengerName(String messengerName) {
          this.messengerName = messengerName;
      }
  
      /** Getter for property destination.
       * @return Value of property destination.
       */
      public Destination getDestination() throws JMSException {
          if ( destination == null ) {
              destination = getMessenger().getDestination( getSubject() );
          }
          return destination;
      }
  
      /** Setter for property destination.
       * @param destination New value of property destination.
       */
      public void setDestination(Destination destination) {
         this.destination = destination;
     }
 
     /** Getter for property subject.
      * @return Value of property subject.
      */
     public String getSubject() {
         return subject;
     }
 
     /** Setter for property subject.
      * @param subject New value of property subject.
      */
     public void setSubject(String subject) {
         this.subject = subject;
     }
     
     
     /** Getter for property messengerManager.
      * @return Value of property messengerManager.
      */
     public MessengerManager getMessengerManager() {
         return messengerManager;
     }
     
     /** Setter for property messengerManager.
      * @param messengerManager New value of property messengerManager.
      */
     public void setMessengerManager(MessengerManager messengerManager) {
         this.messengerManager = messengerManager;
     }
 
     /** 
      * Sets the URI of the Messenger.xml configuration document to use
      * to configure the messengers to use for this task.
      */
     public void setConfiguration(String uri) throws JMSException {
         setMessengerManager( MessengerManager.load( uri ) );
     }
     
     /** 
      * @return the number of messages to receive.
      * A number less than or equal to 0 will receive messages forever
      */
     public int getCount() {
         return count;
     }
     
     /** 
      * Setter for the number of messages to receive.
      * A number less than or equal to 0 will receive messages forever
      */
     public void setCount(int count) {
         this.count = count;
     }
     
     
     // Task interface
     //-------------------------------------------------------------------------
     
     /**
      * Performs the copy operation.
      */
     public void execute() throws BuildException {
         try {
             Messenger messenger = getMessenger();
             if ( messenger == null ) {
                 throw new BuildException("Must specify a valid Messenger", location );
             }
             Destination destination = getDestination();
             if ( destination == null ) {
                 throw new BuildException("Must specify a valid JMS Destination", location );
             }
 
             if ( count > 0 ) {
                 log( "Will wait until I receive: " + count + " messages and will write to directory: " + dir );
                 
                 for ( int i = 0; i < count; i++ ) {
                     Message message = messenger.receive( destination );
                     processMessage( message );
                 }
                 
                 log( "Finished." );
             }
             else {
                 log( "Infinite loop. Will write to directory: " + dir );
                 
                 while (true) {
                     Message message = messenger.receive( destination );
                     processMessage( message );
                 }
             }
         }
         catch (IOException e) {
             log( "Caught exception: " + e, Project.MSG_ERR );
             throw new BuildException(e, location);
         }
         catch (JMSException e) {
             log( "Caught exception: " + e, Project.MSG_ERR );
             throw new BuildException(e, location);
         }
         finally {        
             try {
                 // close the JMS connection to release any background threads        
                 messenger.close();
             }
             catch (Exception e) {
                 // ignore close exceptions
             }
         }
     }
 
     /**
      * Processes a given message
      */
     protected void processMessage(Message message) throws IOException, JMSException {
         log( "Received message to: " + message );
 
         String text = null;
         if ( message instanceof TextMessage ) {
             TextMessage textMessage = (TextMessage) message;
             text = textMessage.toString();
         }
         else {
             // #### bit of a hack!!!
             // ideally we need an XML format for message persistence
             text = message.toString();
         }       
         processMessageText(text);
     }
     
     /** 
      * Writes the given text to a file
      */
     protected void processMessageText(String text) throws IOException {
         FileWriter writer = new FileWriter( dir );
         writer.write ( text );
         writer.close();
     }
 }