/*
      Copyright 2008 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.util.log;
  
  import static fulmine.util.Utils.string;
  
  import java.text.SimpleDateFormat;
  import java.util.Date;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import fulmine.util.concurrent.ITaskExecutor;
  import fulmine.util.concurrent.ITaskHandler;
  import fulmine.util.concurrent.Task;
  import fulmine.util.concurrent.TaskExecutor;
  
  /**
   * Wraps a {@link Log} and executes the logging operations using an
   * {@link ITaskExecutor}. This ensures that, regardless of the logging framework
   * and configuration, all internal logging is done asynchronously.
   * 
   * @author Ramon Servadei
   */
  public final class AsyncLog implements Log
  {
      /** The single task handler to use for all logging tasks */
      private final static LogTaskHandler handler = new LogTaskHandler();
  
      /** Handles all logging tasks - polls every 5ms for messages */
      static final ITaskExecutor executor =
      // note: no info container
          new TaskExecutor("Log", 5, null);
      static
      {
          System.out.println("Starting logging executor");
          Runtime.getRuntime().addShutdownHook(new Thread()
          {
              public void run()
              {
                  executor.destroy();
              }
          });
          executor.start();
          System.out.println("Started logging executor");
      }
  
      /** log that is wrapped */
      private final Log log;
  
      /**
       * Create an internal {@link Log} identified by the name
       * 
       * @param name
       *            the name for the {@link Log}
       */
      public AsyncLog(String name)
      {
          this.log = LogFactory.getLog(name);
      }
  
      /**
       * Create an internal {@link Log} identified by the class
       * 
       * @param type
       *            the class that will identify the {@link Log}
       */
      public AsyncLog(Class<?> type)
      {
          this.log = LogFactory.getLog(type);
      }
  
      public void debug(Object message, Throwable t)
      {
          log(new Task<LogMessage>(handler, new LogMessage(log, Level.debug,
              Thread.currentThread().getName(), message, t)));
      }
  
      public void debug(Object message)
      {
          log(new Task<LogMessage>(handler, new LogMessage(log, Level.debug,
              Thread.currentThread().getName(), message)));
      }
  
      public void error(Object message, Throwable t)
      {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.error,
             Thread.currentThread().getName(), message, t)));
     }
 
     public void error(Object message)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.error,
             Thread.currentThread().getName(), message)));
     }
 
     public void fatal(Object message, Throwable t)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.fatal,
             Thread.currentThread().getName(), message, t)));
     }
 
     public void fatal(Object message)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.fatal,
             Thread.currentThread().getName(), message)));
     }
 
     public void info(Object message, Throwable t)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.info,
             Thread.currentThread().getName(), message, t)));
     }
 
     public void info(Object message)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.info,
             Thread.currentThread().getName(), message)));
     }
 
     public boolean isDebugEnabled()
     {
         return log.isDebugEnabled();
     }
 
     public boolean isErrorEnabled()
     {
         return log.isErrorEnabled();
     }
 
     public boolean isFatalEnabled()
     {
         return log.isFatalEnabled();
     }
 
     public boolean isInfoEnabled()
     {
         return log.isInfoEnabled();
     }
 
     public boolean isTraceEnabled()
     {
         return log.isTraceEnabled();
     }
 
     public boolean isWarnEnabled()
     {
         return log.isWarnEnabled();
     }
 
     public void trace(Object message, Throwable t)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.trace,
             Thread.currentThread().getName(), message, t)));
     }
 
     public void trace(Object message)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.trace,
             Thread.currentThread().getName(), message)));
     }
 
     public void warn(Object message, Throwable t)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.warn,
             Thread.currentThread().getName(), message, t)));
     }
 
     public void warn(Object message)
     {
         log(new Task<LogMessage>(handler, new LogMessage(log, Level.warn,
             Thread.currentThread().getName(), message)));
     }
 
     private final void log(Task<LogMessage> message)
     {
         AsyncLog.executor.execute(message);
     }
 }
 
 /**
  * A stateless task handler that will process a {@link LogMessage} object.
  * 
  * @author Ramon Servadei
  */
 final class LogTaskHandler implements ITaskHandler<LogMessage>
 {
 
     LogTaskHandler()
     {
         super();
         System.out.println("Constructed LogTaskHandler");
     }
 
     public void handleTask(LogMessage task)
     {
         task.level.handle(task.log, task);
     }
 }
 
 /**
  * Encapsulates a message to log
  * 
  * @author Ramon Servadei
  */
 class LogMessage
 {
     /** The time of the message */
     final Date timeStamp = new Date();
 
     /** The message to log */
     final Object message;
 
     /** The level to log at */
     final Level level;
 
     /** The log to use */
     final Log log;
 
     /** The thread that raised the log message */
     final String threadName;
 
     /** The {@link Throwable} to log, if any */
     final Throwable throwable;
 
     LogMessage(Log log, Level level, String threadName, Object message)
     {
         this(log, level, threadName, message, null);
     }
 
     LogMessage(Log log, Level level, String threadName, Object message,
         Throwable throwable)
     {
         this.log = log;
         this.message = message;
         this.level = level;
         this.threadName = threadName;
         this.throwable = throwable;
     }
 
     boolean hasException()
     {
         return this.throwable != null;
     }
 
     @Override
     public String toString()
     {
         return string(this, "level=" + this.level + ", thread="
             + this.threadName + ", message=" + this.message + ", exception="
             + this.throwable);
     }
 }
 
 /**
  * Expresses logging levels and contains the logic to log to each level.
  * 
  * @author Ramon Servadei
  */
 enum Level
 {
     // the levels
         trace,
         debug,
         info,
         warn,
         error,
         fatal;
 
     /** Used to format the log times */
     private final SimpleDateFormat format =
         new SimpleDateFormat("ddMMMyy:HH:mm:ss:SSS");
 
     /**
      * Handle executing the specific log operation
      * 
      * @param message
      *            the message to log
      */
     void handle(Log log, LogMessage message)
     {
         switch (this)
         {
             case trace:
                 if (message.hasException())
                 {
                     log.trace(formatMessage(message), message.throwable);
                 }
                 else
                 {
                     log.trace(formatMessage(message));
                 }
                 break;
             case debug:
                 if (message.hasException())
                 {
                     log.debug(formatMessage(message), message.throwable);
                 }
                 else
                 {
                     log.debug(formatMessage(message));
                 }
                 break;
             case info:
                 if (message.hasException())
                 {
                     log.info(formatMessage(message), message.throwable);
                 }
                 else
                 {
                     log.info(formatMessage(message));
                 }
                 break;
             case warn:
                 if (message.hasException())
                 {
                     log.warn(formatMessage(message), message.throwable);
                 }
                 else
                 {
                     log.warn(formatMessage(message));
                 }
                 break;
             case error:
                 if (message.hasException())
                 {
                     log.error(formatMessage(message), message.throwable);
                 }
                 else
                 {
                     log.error(formatMessage(message));
                 }
                 break;
             case fatal:
                 if (message.hasException())
                 {
                     log.fatal(formatMessage(message), message.throwable);
                 }
                 else
                 {
                     log.fatal(formatMessage(message));
 
                 }
                 break;
         }
     }
 
     /**
      * Format the message to log
      * 
      * @param message
      *            the message
      * @return the formatted message to log
      */
     private String formatMessage(LogMessage message)
     {
         return format.format(message.timeStamp) + ", Thread ["
             + message.threadName + "] " + message.message;
     }
 }