/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Portions Copyright 2006-2007 Sun Microsystems, Inc.
 */
package org.opends.server.loggers.debug;

import org.opends.server.loggers.*;
import org.opends.server.util.DynamicConstants;
import org.opends.server.types.DebugLogLevel;

import static org.opends.server.util.ServerConstants.PROPERTY_DEBUG_ENABLED;
import static org.opends.server.util.ServerConstants.PROPERTY_DEBUG_TARGET;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * A LoggingConfiguration for the debug logging system.
 */
public class DebugConfiguration extends LoggerConfiguration
{
  private static final String GLOBAL= "_global";

  private Map<String, TraceSettings> classTraceSettings;
  private Map<String, Map<String, TraceSettings>> methodTraceSettings;

  /**
   * Error handler for tracing.  Tracing will be disabled
   * if too many errors occur.
   */
  private class DebugErrorHandler implements LoggerErrorHandler
  {
    private static final int ERROR_THRESHOLD= 10;

    private int _loggingErrors= 0;

    /**
     * Error handler for tracing.  Tracing will be disabled
     * if too many errors occur.
     *
     * @param record the log record that caused the error to occur.
     * @param ex the exception thrown.
     */
    public synchronized void handleError(LogRecord record, Throwable ex)
    {
      _loggingErrors++;

      DebugLogFormatter formatter = new DebugLogFormatter();
      System.err.println("Error publishing record: " +
          formatter.format(record) + ex);

      // If we've had too many write errors, just turn off
      // tracing to prevent an overflow of messages.
      if (_loggingErrors >= ERROR_THRESHOLD) {
        System.err.println("TOO MANY ERRORS FROM DEBUG LOGGER. SHUTTING DOWN");

        enabled = false;
      }
    }
  }

  /**
   * Construct a default configuration where the logger is disabled and the
   * global scope will only log at the ERROR level.
   */
  public DebugConfiguration()
  {
    super(null);
    this.setErrorHandler(new DebugErrorHandler());
    classTraceSettings = null;
    methodTraceSettings = null;

    //Set the global settings so that only errors are logged.
    addTraceSettings(null, new TraceSettings(DebugLogLevel.ERROR));
  }

  /**
   * Gets the method trace levels for a specified class.
   * @param className - a fully qualified class name to get method trace
   * levels for
   * @return an unmodifiable map of trace levels keyed by method name.  If
   * no method level tracing is configured for the scope, <b>null</b> is
   * returned.
   */
  public Map<String, TraceSettings> getMethodSettings(String className)
  {
    Map<String, TraceSettings> levels = null;

    if (enabled && methodTraceSettings != null) {
      // Method levels are always at leaves in the
      // hierarchy, so don't bother searching up.
      Map<String, TraceSettings> value= methodTraceSettings.get(className);
      if (value != null ) {
        levels= value;
      }
    }
    return levels != null ? Collections.unmodifiableMap(levels) : null;
  }

  /**
   * Get the trace settings for a specified class.
   * @param className - a fully qualified class name to get the
   * trace level for
   * @return the current trace settings for the class.
   */
  public TraceSettings getTraceSettings(String className)
  {
    TraceSettings settings = TraceSettings.DISABLED;

    // If we're not enabled, trace level is DISABLED.
    if (enabled  && classTraceSettings != null) {
      // Find most specific trace setting which covers this
      // fully qualified class name
      // Search up the hierarchy for a match.
      String searchName= className;
      Object value= null;
      value= classTraceSettings.get(searchName);
      while (value == null && searchName != null) {
        int clipPoint= searchName.lastIndexOf('$');
        if (clipPoint == -1) clipPoint= searchName.lastIndexOf('.');
        if (clipPoint != -1) {
          searchName= searchName.substring(0, clipPoint);
          value= classTraceSettings.get(searchName);
        }
        else {
          searchName= null;
        }
      }

      // Use global settings, if nothing more specific was found.
      if (value == null) value= classTraceSettings.get(GLOBAL);

      if (value != null) {
        settings= (TraceSettings)value;
      }
    }
    return settings;
  }

  /**
   * Adds a trace settings to the current set for a specified scope. If a
   * scope is not specified, the settings will be set for the global scope.
   * The global scope settings are used when no other scope matches.
   *
   * @param scope - the scope to set trace settings for; this is a fully
   * qualified class name or null to set the trace settings for the global
   * scope.
   * @param settings - the trace settings for the scope
   */
  public void addTraceSettings(String scope, TraceSettings settings)
  {
    if (scope == null) {
      setClassSettings(GLOBAL, settings);
    }
    else {
      int methodPt= scope.lastIndexOf('#');
      if (methodPt != -1) {
        String methodName= scope.substring(methodPt+1);
        scope= scope.substring(0, methodPt);
        setMethodSettings(scope, methodName, settings);
      }
      else {
        setClassSettings(scope, settings);
      }
    }
  }

  private synchronized void setClassSettings(String className,
                                             TraceSettings settings)
  {
    if(classTraceSettings == null) classTraceSettings =
        new HashMap<String, TraceSettings>();

    classTraceSettings.put(className, settings);
  }

  private synchronized void setMethodSettings(String className,
                                              String methodName,
                                              TraceSettings settings)
  {
    if (methodTraceSettings == null) methodTraceSettings =
        new HashMap<String, Map<String, TraceSettings>>();
    Map<String, TraceSettings> methodLevels=
        methodTraceSettings.get(className);
    if (methodLevels == null) {
      methodLevels= new TreeMap<String, TraceSettings>();
      methodTraceSettings.put(className, methodLevels);
    }

    methodLevels.put(methodName, settings);
  }

  /**
   * Retrieve the initial configuration to use on debug logger startup. Settings
   * are read from system properties.
   * If this is not a debug build of OpenDS, the resulting configuration is
   * always disabled.
   *
   * @return the initial configuration to use for the debug logger.
   */
  public static DebugConfiguration getStartupConfiguration()
  {

    String enabledProp = System.getProperty(PROPERTY_DEBUG_ENABLED);
    if(DynamicConstants.WEAVE_ENABLED && (enabledProp != null &&
        (enabledProp.startsWith("T") || enabledProp.startsWith("t") ||
            enabledProp.startsWith("Y") || enabledProp.startsWith("y"))))
    {
      DebugConfiguration config = new DebugConfiguration();
      config.setEnabled(true);

      TextLogPublisher consolePublisher =
          new TextLogPublisher(TextWriter.STDOUT, new DebugLogFormatter());
      config.addPublisher(consolePublisher);

      Set<Map.Entry<Object, Object>> propertyEntries =
          System.getProperties().entrySet();
      for(Map.Entry<Object, Object> entry : propertyEntries)
      {
        if(((String)entry.getKey()).startsWith(PROPERTY_DEBUG_TARGET))
        {
          String value = (String)entry.getValue();
          int settingsStart= value.indexOf(":");

          //See if the scope and settings exists
          if(settingsStart > 0)
          {
            String scope = value.substring(0, settingsStart);
            TraceSettings settings =
                TraceSettings.parseTraceSettings(
                    value.substring(settingsStart+1));
            if(settings != null)
            {
              config.addTraceSettings(scope, settings);
            }
          }
        }
      }

      return config;
    }
    else
    {
      //If it is not enabled or not a debug build, just return the default
      //off config.
      return new DebugConfiguration();
    }
  }
}