/*
    * 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: ProducerTask.java 155459 2005-02-26 13:24:44Z dirkv $
    */
  package org.apache.commons.messenger.task;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.Reader;
  import java.util.Iterator;
  import java.util.Vector;
  
  import javax.jms.Destination;
  import javax.jms.JMSException;
  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.DirectoryScanner;
  import org.apache.tools.ant.Task;
  import org.apache.tools.ant.types.FileSet;
  
  /** 
   * <p><code>ProducerTask</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 ProducerTask extends Task {
  
      private Vector filesets = new Vector();
      private Messenger messenger;
      private String messengerName;
      private Destination destination;
      private String subject;
      private MessengerManager messengerManager;   
      private File file; 
  
      /** Holds value of property sleep. */
      private long sleep;
      
      // Properties
      //-------------------------------------------------------------------------
      
  
      /**
       * Adds a set of files (nested fileset attribute).
       */
      public void addFileset(FileSet set) {
          filesets.addElement(set);
      }
  
      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 ) );
     }
     
     /** Getter for property sleep, which defines the number of milliseconds to 
      * sleep for before each send.
      * @return Value of property sleep.
      */
     public long getSleep() {
         return sleep;
     }
     
     /** Setter for property sleep, which defines the number of milliseconds to 
      * sleep for before each send.
      * @param sleep New value of property sleep.
      */
     public void setSleep(long sleep) {
         this.sleep = sleep;
     }
     
     /**
      * Returns the single file to be sent instead of a FileSet
      * @return File
      */
     public File getFile() {
         return file;
     }
 
     /**
      * Allows a single file to be sent via the Ant Task
      * @param file The file to set
      */
     public void setFile(File file) {
         this.file = file;
     }
 
     // Task interface
     //-------------------------------------------------------------------------
     
     /**
      * Performs the copy operation.
      */
     public void execute() throws BuildException {
         try {
             if (filesets.size() == 0) {
                 throw new BuildException("Specify at least one source fileset.", location);
             }
             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 ( sleep > 0 ) {
                 log( "Will sleep for: " + sleep + " (ms) between message sends" );
             }
                     
             // deal with the filesets
             boolean first = true;
             if (file != null ) {
                 sendFile(file, messenger, destination);
             }
             else {
                 for (Iterator iter = filesets.iterator(); iter.hasNext(); ) {
                     FileSet fs = (FileSet) iter.next();
                     DirectoryScanner ds = fs.getDirectoryScanner(project);                
                     ds.scan();
     
                     File dir = ds.getBasedir();
                     String[] files = ds.getIncludedFiles();
                     
                     for (int i = 0; i < files.length; i++) {
                         if ( first ) {
                             first = false;
                         }
                         else {
                             sleep();
                         }
                         sendFile( new File( dir, files[i]), messenger, destination );
                     }
                 }
             }
         }
         catch (IOException e) {
             throw new BuildException(e, location);
         }
         catch (JMSException e) {
             throw new BuildException(e, location);
         }
         finally {        
             try {
                 // close the JMS connection to release any background threads        
                 messenger.close();
             }
             catch (Exception e) {
                 // ignore close exceptions
             }
         }
     }
 
     /**
      * Sends the contents of the given file to the given Destination 
      * using the given Messenger instance
      */
     protected void sendFile(File file, Messenger messenger, Destination destination) throws IOException, JMSException {
         log( "Sending message to: " + destination + " from file: " + file );
         
         String text = readText(
             new BufferedReader( new FileReader( file ) )
         );
         
         TextMessage message = messenger.createTextMessage( text );
         
         messenger.send( destination, message );
     }
     
     /** 
      * Reads the given text stream into a single string 
      */
     protected String readText(Reader in) throws IOException {
         // read all the text into memory
         StringBuffer buffer = new StringBuffer();
         BufferedReader reader = new BufferedReader( in );
         for ( String line; (line = reader.readLine()) != null; ) {
             buffer.append( line );
             buffer.append( '\n' );
         }
         reader.close();
         return buffer.toString();
     }
     
     /**
      * Sleeps for a configurable amount of time between each message send 
      */
     protected void sleep() {
         if ( sleep > 0 ) {
             try {
                 Thread.sleep(sleep);
             }
             catch (InterruptedException e) {
                 // ignore interuptions
             }
         }
     }
 }