/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.uima.util.impl;

import java.io.OutputStream;
import java.io.PrintStream;
import java.text.MessageFormat;
import java.util.logging.Handler;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;

import org.apache.uima.internal.util.UIMALogFormatter;
import org.apache.uima.internal.util.UIMAStreamHandler;
import org.apache.uima.util.Level;
import org.apache.uima.util.Logger;
import org.slf4j.Marker;
import org.slf4j.helpers.MessageFormatter;

/**
 * UIMA Logging interface implementation for Java Logging Toolkit JSR-47 (JDK 1.4) JUL
 * 
 * Ignores Markers and MDC (not supported in the JUL)
 */
public class JSR47Logger_impl extends Logger_common_impl {

  final static private Object[] zeroLengthArray = new Object[0];

  /**
   * logger object from the underlying JSR-47 logging framework
   */
  final private java.util.logging.Logger logger;

  /**
   * create a new LogWrapper class for the specified source class
   * 
   * @param component
   *          specified source class
   */
  private JSR47Logger_impl(Class<?> component) {
    super(component);

    logger = java.util.logging.Logger
            .getLogger((component != null) ? component.getName() : "org.apache.uima");
  }

  private JSR47Logger_impl(JSR47Logger_impl l, int limit) {
    super(l, limit);
    logger = l.logger;
  }

  /**
   * Creates a new JSR47Logger instance for the specified source class
   * 
   * @param component
   *          current source class
   * 
   * @return Logger returns the JSR47Logger object for the specified class
   */
  public static synchronized Logger getInstance(Class<?> component) {
    return new JSR47Logger_impl(component);
  }

  public static synchronized Logger getInstance(JSR47Logger_impl l, int limit) {
    if (limit == Integer.MAX_VALUE) {
      return l;
    }
    return new JSR47Logger_impl(l, limit);
  }

  /**
   * Creates a new JSR47Logger instance with the default JSR-47 framework logger
   * 
   * @return Logger returns the JSR47Logger object with the default JSR-47 framework logger
   */
  public static synchronized JSR47Logger_impl getInstance() {
    return new JSR47Logger_impl(null);
  }

  @Override
  public JSR47Logger_impl getLimitedLogger(int limit) {
    if (limit == Integer.MAX_VALUE || limit == limit_common) {
      return this;
    }
    return new JSR47Logger_impl(this, limit);
  }

  /**
   * @see org.apache.uima.util.Logger#setOutputStream(java.io.OutputStream)
   * 
   * @deprecated use external configuration possibility
   */
  @Override
  @Deprecated
  public void setOutputStream(OutputStream out) {
    // if OutputStream is null set root logger level to OFF
    if (out == null) {
      LogManager.getLogManager().getLogger("").setLevel(java.util.logging.Level.OFF);
      return;
    }

    // get root logger handlers - root logger is parent of all loggers
    Handler[] handlers = LogManager.getLogManager().getLogger("").getHandlers();

    // remove all current handlers
    for (int i = 0; i < handlers.length; i++) {
      LogManager.getLogManager().getLogger("").removeHandler(handlers[i]);
    }

    // add new UIMAStreamHandler with the given output stream
    UIMAStreamHandler streamHandler = new UIMAStreamHandler(out, new UIMALogFormatter());
    streamHandler.setLevel(java.util.logging.Level.ALL);
    LogManager.getLogManager().getLogger("").addHandler(streamHandler);
  }

  /**
   * @see org.apache.uima.util.Logger#setOutputStream(java.io.PrintStream)
   * 
   * @deprecated use external configuration possibility
   */
  @Override
  @Deprecated
  public void setOutputStream(PrintStream out) {
    // if PrintStream is null set root logger level to OFF
    if (out == null) {
      LogManager.getLogManager().getLogger("").setLevel(java.util.logging.Level.OFF);
      return;
    }

    // get root logger handlers - root logger is parent of all loggers
    Handler[] handlers = LogManager.getLogManager().getLogger("").getHandlers();

    // remove all current handlers
    for (int i = 0; i < handlers.length; i++) {
      LogManager.getLogManager().getLogger("").removeHandler(handlers[i]);
    }

    // add new UIMAStreamHandler with the given output stream
    UIMAStreamHandler streamHandler = new UIMAStreamHandler(out, new UIMALogFormatter());
    streamHandler.setLevel(java.util.logging.Level.ALL);
    LogManager.getLogManager().getLogger("").addHandler(streamHandler);
  }

  /**
   * JSR-47 level mapping to UIMA level mapping.
   * 
   * Maps via marker values for UIMA_MARKER_CONFIG and UIMA_MARKER_FINEST
   * 
   * SEVERE (highest value) -%gt; SEVERE<br>
   * WARNING -%gt; WARNING<br>
   * INFO -%gt; INFO <br>
   * CONFIG -%gt; CONFIG <br>
   * FINE -%gt; FINE<br>
   * FINER -%gt; FINER <br>
   * FINEST (lowest value) -%gt; FINEST<br>
   * OFF -%gt; OFF <br>
   * ALL -%gt; ALL<br>
   * 
   * @param level
   *          uima level
   * @param m
   *          the marker
   * 
   * @return Level - corresponding JSR47 level
   */
  public static java.util.logging.Level getJSR47Level(Level level, Marker m) {
    if (null == level) {
      return null;
    }
    switch (level.toInteger()) {
      case org.apache.uima.util.Level.OFF_INT:
        return java.util.logging.Level.OFF;
      case org.apache.uima.util.Level.SEVERE_INT:
        return java.util.logging.Level.SEVERE;
      case org.apache.uima.util.Level.WARNING_INT:
        return java.util.logging.Level.WARNING;
      case org.apache.uima.util.Level.INFO_INT:
        return (m == UIMA_MARKER_CONFIG) ? java.util.logging.Level.CONFIG
                : java.util.logging.Level.INFO;
      case org.apache.uima.util.Level.CONFIG_INT:
        return java.util.logging.Level.CONFIG;
      case org.apache.uima.util.Level.FINE_INT:
        return java.util.logging.Level.FINE;
      case org.apache.uima.util.Level.FINER_INT:
        // could be DEBUG with marker FINEST, DEBUG_INT == FINER_INT
        return (m == UIMA_MARKER_FINEST) ? java.util.logging.Level.FINEST
                : java.util.logging.Level.FINER;
      case org.apache.uima.util.Level.FINEST_INT:
        return java.util.logging.Level.FINEST;

      default: // for all other cases return Level.ALL
        return java.util.logging.Level.ALL;
    }
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.apache.uima.util.Logger#isLoggable(org.apache.uima.util.Level)
   */
  @Override
  public boolean isLoggable(Level level) {
    return logger.isLoggable(getJSR47Level(level, null));
  }

  @Override
  public boolean isLoggable(Level level, Marker m) {
    return logger.isLoggable(getJSR47Level(level, m));
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.apache.uima.util.Logger#setLevel(org.apache.uima.util.Level)
   */
  @Override
  public void setLevel(Level level) {
    logger.setLevel(getJSR47Level(level, null));
  }

  // /**
  // * Log the message at the specified level with the specified throwable if any.
  // * This method creates a LogRecord and fills in caller date before calling
  // * this instance's JDK14 logger.
  // *
  // * See bug report #13 for more details.
  // *
  // * @param level
  // * @param msg
  // * @param t
  // */
  // private void log(String callerFQCN, Level level, String msg, Throwable t) {
  // // millis and thread are filled by the constructor
  // LogRecord record = new LogRecord(level, msg);
  // record.setLoggerName(getName());
  // record.setThrown(t);
  // // Note: parameters in record are not set because SLF4J only
  // // supports a single formatting style
  // fillCallerData(callerFQCN, record);
  // logger.log(record);
  // }

  @Override
  public void log(Marker m, String aFqcn, Level level, String msg, Object[] args,
          Throwable throwable) {
    if (isLoggable(level, m)) {
      log(m, aFqcn, level, MessageFormat.format(msg, args), throwable);
    }
  }

  @Override
  public void log(Marker m, String aFqcn, Level level, String msg, Throwable throwable) {
    if (isLoggable(level, m)) {
      LogRecord record = new LogRecord(getJSR47Level(level, m), msg);
      record.setLoggerName(getName());
      record.setThrown(throwable);

      StackTraceElement[] elements = new Throwable().getStackTrace();
      StackTraceElement top = null;

      boolean found = false;

      for (int i = 0; i < elements.length; i++) {
        final String className = elements[i].getClassName();
        if (className.equals(aFqcn)) {
          if (found) {
            continue; // keep going until not found
          } else {
            found = true;
            continue;
          }
        } else {
          if (found) {
            top = elements[i];
            break;
          }
        }
      }

      if (top != null) {
        record.setSourceClassName(top.getClassName());
        record.setSourceMethodName(top.getMethodName() + "(" + top.getLineNumber() + ")");
      }
      logger.log(record);
    }
  }

  @Override
  public void log2(Marker m, String aFqcn, Level level, String msg, Object[] args,
          Throwable throwable) {
    // this version of MessageFormatter does the {} style
    log(m, aFqcn, level, MessageFormatter.format(msg, args).getMessage(), zeroLengthArray,
            throwable);
  }

  @Override
  public String getName() {
    return logger.getName();
  }

  @Override
  public boolean isDebugEnabled() {
    return logger.isLoggable(java.util.logging.Level.FINE);
  }

  @Override
  public boolean isDebugEnabled(Marker arg0) {
    return isDebugEnabled();
  }

  @Override
  public boolean isErrorEnabled() {
    return logger.isLoggable(java.util.logging.Level.SEVERE);
  }

  @Override
  public boolean isErrorEnabled(Marker arg0) {
    return isErrorEnabled();
  }

  @Override
  public boolean isInfoEnabled() {
    return logger.isLoggable(java.util.logging.Level.INFO)
            || logger.isLoggable(java.util.logging.Level.CONFIG);
  }

  @Override
  public boolean isInfoEnabled(Marker arg0) {
    return isInfoEnabled();
  }

  @Override
  public boolean isTraceEnabled() {
    return logger.isLoggable(java.util.logging.Level.FINER)
            || logger.isLoggable(java.util.logging.Level.FINEST);
  }

  @Override
  public boolean isTraceEnabled(Marker arg0) {
    return isTraceEnabled();
  }

  @Override
  public boolean isWarnEnabled() {
    return logger.isLoggable(java.util.logging.Level.WARNING);
  }

  @Override
  public boolean isWarnEnabled(Marker arg0) {
    return isWarnEnabled();
  }

}
