/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.trace;
  
  import com.gargoylesoftware.base.util.DetailedNullPointerException;
  import com.gargoylesoftware.base.util.StringUtil;
  import java.io.PrintStream;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.text.Format;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.Set;
  
  /***
   * <p style="color: orange">Internal use only.</p>.
   * <p>A dispatcher for TraceItems</p>
   *
   * @version $Revision: 1.9 $
   * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
   */
  public class TraceItemDispatcher implements Runnable {
  
      // Format used for the timestamp in the trace lines
      private static final Format TIMESTAMP_FORMAT = new SimpleDateFormat("HH:mm");
  
      private static final int BUFFER_ENABLED       = 1;
      private static final int BUFFER_SHUTTING_DOWN = 2;
      private static final int BUFFER_DISABLED      = 3;
  
      private static int bufferStatus_ = BUFFER_DISABLED;
  
      private final TraceItemQueue traceQueue_ = new TraceItemQueue();
  
      // For caching TraceItems
      private TraceItemQueue cacheTraceItemQueue_ = new TraceItemQueue();
      private int cacheMaxSize_ = 50;
  
      /***
       *
       */
      public TraceItemDispatcher() {
          new Thread(this, "TraceItemDispatcher Thread").start();
  
          // Add a hook so that buffering will be shut down before the JVM
          // exits.  This will ensure that all information written to Trace
          // will be flushed properly before shutdown.
          //
          // This is done with reflection so that the class will still compile and
          // run in a 1.2 JVM.
          final Runtime runtime = Runtime.getRuntime();
          try {
              final Method method = runtime.getClass().getMethod( "addShutdownHook",
                                                                   new Class[] { Thread.class } );
              final Thread thread =  new Thread() {
                  public void run() {
                      Trace.getController().setBufferingEnabled(false);
                  }
              };
              method.invoke( runtime, new Object[] { thread } );
          }
          catch( NoSuchMethodException e ) {
              // The method wasn't found - we must be running on a 1.2 JVM.  Oh well.
         }
         catch( final IllegalAccessException e ) {
             // Theoretically impossible.
             e.printStackTrace();
         }
         catch( final InvocationTargetException e ) {
             // Theoretically impossible.
             e.getTargetException().printStackTrace();
         }
     }
 
     /***
      *
      */
     public void run() {
         TraceItem item;
 
         // Enable the buffering.  Note that we can't call
         // setBufferingEnabled() at this point because of deadlocks.
         bufferStatus_ = BUFFER_ENABLED;
 
         // The reason for the double try blocks is that we want to continue
         // looping if we get an exception but if we get an error then
         // something is severely wrong so we exit the thread.
         try {
             while(true) {
                 try {
                     item = traceQueue_.pop();
                     if( item == null ) {
                         Thread.sleep(500);
                     }
                     else {
                         dumpTraceElement(item);
                     }
                 }
                 catch( final Exception e ) {
                     System.out.print("Exception when printing debug information e=");
                     e.printStackTrace();
                 }
             }
         }
         catch( final Throwable t ) {
             System.out.print("Exception when printing debug information e=");
             t.printStackTrace();
         }
     }
 
     /***
      * Format an item and print it to standard out.
      * @param item the item to print.
      */
     private void dumpTraceElement( final TraceItem item ) {
         assertNotNull("item", item);
 
         final TraceChannel channel = item.getChannel();
         if( channel != null && channel.isEnabled() && item.containsText() ) {
             final Set traceWriters = channel.getTraceWriters();
             synchronized( traceWriters ) {
                 final Iterator iterator = traceWriters.iterator();
                 if( iterator.hasNext() == false ) {
                     // There aren't any trace writers for this channel
                     defaultTraceWriter(item);
                 }
                 else {
                     while( iterator.hasNext() ) {
                         ((TraceWriter)iterator.next()).write(item);
                     }
                 }
             }
         }
 
         // Is this a synchronous call
         final Object lock = item.getLock();
         if( lock != null ) {
             synchronized(lock) {
                 lock.notify();
             }
             return;
         }
 
         disposeTraceItem(item);
     }
 
     /***
      * Provide default behaviour
      * @param item The item to print
      */
     private static void defaultTraceWriter( final TraceItem item ) {
 
         final PrintStream outStream
         = Trace.getController().getRealSystemOut();
         final StringBuffer prefixBuffer = new StringBuffer();
 
         prefixBuffer.append("[");
         final Date timestamp = item.getTime();
         if( timestamp != null ) {
             prefixBuffer.append( TIMESTAMP_FORMAT.format(timestamp) );
             prefixBuffer.append(" ");
         }
 
         final String threadName = item.getThreadName();
         if( threadName != null ) {
             prefixBuffer.append( threadName );
         }
 
         prefixBuffer.append("] ");
 
         final String prefix = prefixBuffer.toString();
         final String message = item.getMessage();
 
         if( message != null ) {
             outStream.print(prefix);
             outStream.print( StringUtil.expandTabs(message,3) );
         }
 
         final Throwable throwable = item.getThrowable();
 
         if( throwable != null ) {
             int i;
             final String strings[] = Trace.throwableToStringArray(throwable);
 
             outStream.print(prefix);
             outStream.println(strings[0]);
 
             final String blanks = StringUtil.nCopies(prefix.length(), ' ');
             for( i=1; i<strings.length; i++ ) {
                 outStream.print(blanks);
                 outStream.println( StringUtil.expandTabs(strings[i],3) );
             }
         }
     }
 
     /***
      * Get the queue.
      * @return The queue.
      */
     public TraceItemQueue getTraceItemQueue() {
         return traceQueue_;
     }
 
     /***
      * Add an item to the trace queue.
      * @param item The item to add.
      */
     public void dispatch( final TraceItem item ) {
         item.setThread( Thread.currentThread() );
         item.setTime( new Date() );
 
         switch( bufferStatus_ ) {
             case BUFFER_ENABLED:
                 traceQueue_.push(item);
                 break;
 
             case BUFFER_SHUTTING_DOWN:
                 flush();
                 dumpTraceElement(item);
                 break;
 
             case BUFFER_DISABLED:
                 dumpTraceElement(item);
                 break;
 
             default:
                 throw new IllegalStateException(
                                                "Unexpected value: bufferStatus_="
                                                + bufferStatus_);
         }
     }
 
     /***
      *
      */
     // TODO: Use lock_ in TraceItem
     private synchronized void waitForQueueToEmpty() {
         while( traceQueue_.size() != 0 ) {
             try {
                 Thread.sleep(100);
             }
             catch( final InterruptedException e ) {
                 return;
             }
         }
     }
 
     /***
      * Set whether or not to buffer the output of the trace calls.  Buffering
      * will increase perceived performance significantly.
      * @param enabled True if buffering should be enabled
      */
     public synchronized void setBufferingEnabled( final boolean enabled ) {
 
         if( enabled ) {
             if( bufferStatus_ == BUFFER_SHUTTING_DOWN ) {
                 // Block until the buffer has finished shutting down
                 flush();
             }
 
             if( bufferStatus_ == BUFFER_DISABLED ) {
                 bufferStatus_ = BUFFER_ENABLED;
             }
         }
         else {
             if( bufferStatus_ == BUFFER_ENABLED ) {
                 bufferStatus_ = BUFFER_SHUTTING_DOWN;
                 flush();
                 bufferStatus_ = BUFFER_DISABLED;
             }
         }
     }
 
     /***
      * Return true if buffering is enabled.
      * @return true if buffering is enabled.
      */
     public boolean isBufferingEnabled() {
         return bufferStatus_ == BUFFER_ENABLED;
     }
 
     /***
      *
      */
     public void flush() {
 
         switch( bufferStatus_ ) {
             case BUFFER_ENABLED:
                 final TraceItem item = getNewTraceItem();
                 final Object lock = new Object();
                 item.setLock( lock );
                 try {
                     synchronized(lock) {
                         dispatch( item );
                         lock.wait();
                     }
                 }
                 catch( final InterruptedException e ) {
                     // Expected path
                 }
                 break;
 
             case BUFFER_SHUTTING_DOWN:
                 waitForQueueToEmpty();
                 break;
 
             case BUFFER_DISABLED:
                 return;
 
             default:
                 throw new IllegalStateException(
                                                "Unexpected value: bufferStatus_="
                                                + bufferStatus_);
         }
     }
 
     /***
      * Return a trace item
      * @return The new trace item.
      */
     public TraceItem getNewTraceItem() {
         TraceItem item = cacheTraceItemQueue_.pop();
         if( item == null ) {
             item = new TraceItem();
         }
 
         return item;
     }
 
     /***
      * Dispose of a trace item.  Disposing will put the trace item back on a queue for reuse.
      * @param item The item to dispose.
      */
     public void disposeTraceItem( final TraceItem item ) {
         if( cacheTraceItemQueue_.size() < cacheMaxSize_ ) {
             item.clear();
             cacheTraceItemQueue_.push(item);
         }
     }
 
 
     /***
      * Verify that the specified value is not null.  If it is then throw an exception
      *
      * @param fieldName The name of the field to check
      * @param fieldValue The value of the field to check
      * @exception DetailedNullPointerException If fieldValue is null
      */
     protected final void assertNotNull( final String fieldName, final Object fieldValue )
         throws DetailedNullPointerException {
 
         if( fieldValue == null ) {
             throw new DetailedNullPointerException(fieldName);
         }
     }
 }