/*
 * Created on Dec 5, 2005
 *
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package wbitest;
import javax.jms.*;

//Imports for JNDI
import javax.naming.*;
import javax.naming.directory.*;

//Used for JNDI initialisation
import java.util.Hashtable;

//The following import would not normally be required in a JMS application,
//but is included here to allow us to bypass the JNDI lookup stage
import com.ibm.mq.jms.MQQueueConnectionFactory;

//Import required for program tracing
import com.ibm.mq.jms.services.ConfigEnvironment;
/**
 * 
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class QueuePut extends  QueueTest{

	public static void main( String[] args )
	  {
	    String                  outString    =
	      "A simple text message from PTPSample01";
	    Queue                   ioQueue      = null;
	    QueueSession            session      = null;
	    QueueConnection         connection   = null;
	    QueueConnectionFactory  factory      = null;
	    Context                 ctx          = null;
	
	    boolean            useJNDI      = true;
	    boolean            enableTrace  = false;
	    String             icf          = "com.sun.jndi.fscontext.RefFSContextFactory";
	    String             url          = null;
	
	    System.out.println( "\n5648-C60, 5724-B41, 5655-F10 (c) Copyright IBM Corp. 1999. " +
				"All Rights Reserved.");
	    System.out.println( "Websphere MQ classes for Java(tm) Message Service - "+
				"Point to Point Sample 1"+ "\n" );
	
	    // Process each of the command-line arguments in turn
	    for( int i=0; i<args.length; i++ ) {
	      String arg = args[i].toLowerCase();
	
	      if( arg.equals("-nojndi") ) {
		// If the nojndi flag has been set then the program will not
		// use JNDI to obtain the administered objects, but will
		// create them at runtime
		useJNDI = false;
	      } else if( arg.equals("-m") ) {
		// Obtain the name of the queue manager to connect to if we
		// are not using JNDI
		if (i+1< args.length)
		  QMGR = args[++i];
		else
		  System.out.println("Ignoring -m flag; no value supplied");
	      } else if( arg.equals("-t") ) {
		// Enable program tracing
		enableTrace = true;
	      } else if( arg.equals("-url") ) {
		// Obtain the URL for JNDI operations
		if( i+1<args.length )
		  url = args[++i];
		else
		  System.out.println( "Ignoring -url flag; " +
				      "no value supplied");
	      } else if( arg.equals("-icf") ) {
		// Obtain the name of the class used for creating JNDI's
		// initialContext
		if( i+1<args.length )
		  icf = args[++i];
		else
		  System.out.println( "Ignoring -icf flag; " +
				      "no value supplied");
	      } else
		// Report and discard any unknown command-line options
		System.out.println("Ignoring unknown flag: " + arg );
	    }
	
	    // Enable trace, if this is required
	    if( enableTrace )
	      ConfigEnvironment.start();
	
	    // For simplicity this sample uses a single try block to catch all
	    // Exceptions. In a real application you would probably use several
	    // try blocks, allowing more specific error reporting and more options
	    // for recovery.
	    try {
	
	      // Get the connection factory
	      if( useJNDI ) {
		// obtain the initial context
		ctx = initJNDI(icf, url);
		// get the connection factory from JNDI
		factory = getConnectionFactoryFromJNDI(ctx, qcfLookup);
	      } else {
		// create a connection factory directly
		// Note that this requires a reference to the underlying
		// class that implements QueueConnectionFactory
		System.out.println("Creating a QueueConnectionFactory");
		factory = new MQQueueConnectionFactory();
		((MQQueueConnectionFactory)factory).setQueueManager(QMGR);
	      }
	
	      // Create a QueueConnection from the QueueConnectionFactory
	      System.out.println("Creating a Connection");
	      connection = factory.createQueueConnection();
	
	      // IMPORTANT: Receive calls will be blocked if the connection is
	      // not explicitly started, so make sure that we do so!
	      System.out.println("Starting the Connection");
	      connection.start();
	
	      // We now create a QueueSession from the connection. Here we
	      // specify that it shouldn't be transacted, and that it should
	      // automatically acknowledge received messages
	      System.out.println("Creating a Session");
	      boolean transacted = false;
	      session = connection.createQueueSession( transacted,
						       Session.AUTO_ACKNOWLEDGE);
	
	      // Get the Queue (the specification of where to send our message)
	      if( useJNDI ) {
		// get the Queue from JNDI
		ioQueue = getQueueFromJNDI(ctx, qLookup);
	      } else {
		// Use the session to create the queue object, supplying
		// the required MQ-specific parameter
		ioQueue = session.createQueue( QUEUE );
	      }
	
	      // We now use the session to create a QueueSender, passing in the
	      // destination (the Queue object) as a parameter
	      System.out.println("Creating a QueueSender");
	      QueueSender queueSender = session.createSender(ioQueue);
	
		
	      // The session is used to create messages, so create an empty
	      // TextMessage and fill it with some data
	      System.out.println( "Creating a TextMessage" );
	      TextMessage outMessage = session.createTextMessage();
	      System.out.println("Adding Text");
	      outMessage.setText(outString);
	
	      // Ask the QueueSender to send the message we have created
	      System.out.println( "Sending the message to " + ioQueue.getQueueName() );
	      queueSender.send(outMessage);
	
	
		
	

	      // Closing QueueSender
	      System.out.println("Closing QueueSender");
	      queueSender.close();
	
	      // Closing QueueSesssion.
	      System.out.println("Closing Session");
	      session.close();
	      session = null;
	
	      // Closing QueueConnection.
	      System.out.println("Closing Connection");
	      connection.close();
	      connection = null;
	
	    } catch( JMSException je ) {
	      System.out.println("caught JMSException: " + je);
	      // check for a linked exception that provides more detail
	      Exception le = je.getLinkedException();
	      if (le != null) System.out.println("linked exception: "+le);
		
	    } catch( Exception e ) {
	      // This catches any exception thrown in the main body of
	      // the program, displaying it on screen
	      System.out.println("Caught exception: " + e );
	
	    } finally {
	      // A finally block is a good place to ensure that we don't forget
	      // to close the most important JMS objects
	      try {
		if (session != null) {
		  System.out.println("closing session");
		  session.close();
		}
		if (connection != null) {
		  System.out.println("closing connection");
		  connection.close();
		}
	      } catch (JMSException je) {
		System.out.println("failed with "+je);
	      }
	    }
	
	    System.out.println("finished");
	  }

}