/*
 * 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 legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * 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 legal-notices/CDDLv1_0.txt.
 * 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
 *
 *
 *      Copyright 2008-2009 Sun Microsystems, Inc.
 *      Portions Copyright 2012-2015 ForgeRock AS.
 */
package org.opends.server.admin;



import static org.opends.messages.AdminMessages.*;
import static org.opends.messages.ExtensionMessages.*;
import static org.opends.server.util.StaticUtils.*;
import static org.opends.server.util.ServerConstants.EOL;

import java.io.ByteArrayOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

import org.forgerock.i18n.LocalizableMessage;
import org.opends.server.admin.std.meta.RootCfgDefn;
import org.opends.server.core.DirectoryServer;
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.opends.server.types.InitializationException;


/**
 * Manages the class loader which should be used for loading configuration definition classes and associated extensions.
 * <p>
 * For extensions which define their own extended configuration definitions, the class loader will make sure
 * that the configuration definition classes are loaded and initialized.
 * <p>
 * Initially the class loader provider is disabled, and calls to the {@link #getClassLoader()} will return
 * the system default class loader.
 * <p>
 * Applications <b>MUST NOT</b> maintain persistent references to the class loader as it can change at run-time.
 */
public final class ClassLoaderProvider {
  private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();

  /**
   * Private URLClassLoader implementation.
   * This is only required so that we can provide access to the addURL method.
   */
  private static final class MyURLClassLoader extends URLClassLoader {

    /** Create a class loader with the default parent class loader. */
    public MyURLClassLoader() {
      super(new URL[0]);
    }



    /**
     * Create a class loader with the provided parent class loader.
     *
     * @param parent
     *          The parent class loader.
     */
    public MyURLClassLoader(ClassLoader parent) {
      super(new URL[0], parent);
    }



    /**
     * Add a Jar file to this class loader.
     *
     * @param jarFile
     *          The name of the Jar file.
     * @throws MalformedURLException
     *           If a protocol handler for the URL could not be found, or if some other error occurred
     *           while constructing the URL.
     * @throws SecurityException
     *           If a required system property value cannot be accessed.
     */
    public void addJarFile(File jarFile) throws SecurityException, MalformedURLException {
      addURL(jarFile.toURI().toURL());
    }

  }

  /** The name of the manifest file listing the core configuration definition classes. */
  private static final String CORE_MANIFEST = "core.manifest";

  /** The name of the manifest file listing a extension's configuration definition classes. */
  private static final String EXTENSION_MANIFEST = "extension.manifest";

  /** The name of the lib directory. */
  private static final String LIB_DIR = "lib";

  /** The name of the extensions directory. */
  private static final String EXTENSIONS_DIR = "extensions";

  /** The singleton instance. */
  private static final ClassLoaderProvider INSTANCE = new ClassLoaderProvider();

  /** Attribute name in jar's MANIFEST corresponding to the revision number. */
  private static final String REVISION_NUMBER = "Revision-Number";

  /** The attribute names for build information is name, version and revision number. */
  private static final String[] BUILD_INFORMATION_ATTRIBUTE_NAMES =
                 new String[]{Attributes.Name.EXTENSION_NAME.toString(),
                              Attributes.Name.IMPLEMENTATION_VERSION.toString(),
                              REVISION_NUMBER};


  /**
   * Get the single application wide class loader provider instance.
   *
   * @return Returns the single application wide class loader provider instance.
   */
  public static ClassLoaderProvider getInstance() {
    return INSTANCE;
  }

  /** Set of registered Jar files. */
  private Set<File> jarFiles = new HashSet<>();

  /**
   * Underlying class loader used to load classes and resources (null if disabled).<br>
   * We contain a reference to the URLClassLoader rather than sub-class it so that it is possible to replace the
   * loader at run-time. For example, when removing or replacing extension Jar files (the URLClassLoader
   * only supports adding new URLs, not removal).
   */
  private MyURLClassLoader loader;



  /** Private constructor. */
  private ClassLoaderProvider() {
    // No implementation required.
  }



  /**
   * Disable this class loader provider and removed any registered extensions.
   *
   * @throws IllegalStateException
   *           If this class loader provider is already disabled.
   */
  public synchronized void disable()
      throws IllegalStateException {
    if (loader == null) {
      throw new IllegalStateException(
          "Class loader provider already disabled.");
    }
    loader = null;
    jarFiles = new HashSet<>();
  }



  /**
   * Enable this class loader provider using the application's class loader as the parent class loader.
   *
   * @throws InitializationException
   *           If the class loader provider could not initialize successfully.
   * @throws IllegalStateException
   *           If this class loader provider is already enabled.
   */
  public synchronized void enable()
      throws InitializationException, IllegalStateException {
    enable(RootCfgDefn.class.getClassLoader());
  }



  /**
   * Enable this class loader provider using the provided parent class loader.
   *
   * @param parent
   *          The parent class loader.
   * @throws InitializationException
   *           If the class loader provider could not initialize successfully.
   * @throws IllegalStateException
   *           If this class loader provider is already enabled.
   */
  public synchronized void enable(ClassLoader parent)
      throws InitializationException, IllegalStateException {
    if (loader != null) {
      throw new IllegalStateException("Class loader provider already enabled.");
    }

    if (parent != null) {
      loader = new MyURLClassLoader(parent);
    } else {
      loader = new MyURLClassLoader();
    }

    // Forcefully load all configuration definition classes in OpenDJ.jar.
    initializeCoreComponents();

    // Put extensions jars into the class loader and load all configuration definition classes in that they contain.
    // First load the extension from the install directory, then from the instance directory.
    File installExtensionsPath  = buildExtensionPath(DirectoryServer.getServerRoot());
    File instanceExtensionsPath = buildExtensionPath(DirectoryServer.getInstanceRoot());

    initializeAllExtensions(installExtensionsPath);

    if (! installExtensionsPath.getAbsolutePath().equals(instanceExtensionsPath.getAbsolutePath())) {
      initializeAllExtensions(instanceExtensionsPath);
    }
  }

  private File buildExtensionPath(String directory)  {
    File libDir = new File(directory, LIB_DIR);
    try {
      return new File(libDir, EXTENSIONS_DIR).getCanonicalFile();
    } catch (Exception e) {
      return new File(libDir, EXTENSIONS_DIR);
    }
  }


  /**
   * Gets the class loader which should be used for loading classes and resources. When this class loader provider
   * is disabled, the system default class loader will be returned by default.
   * <p>
   * Applications <b>MUST NOT</b> maintain persistent references to the class loader as it can change at run-time.
   *
   * @return Returns the class loader which should be used for loading classes and resources.
   */
  public synchronized ClassLoader getClassLoader() {
    if (loader != null) {
      return loader;
    } else {
      return ClassLoader.getSystemClassLoader();
    }
  }



  /**
   * Indicates whether this class loader provider is enabled.
   *
   * @return Returns <code>true</code> if this class loader provider is enabled.
   */
  public synchronized boolean isEnabled() {
    return loader != null;
  }



  /**
   * Add the named extensions to this class loader.
   *
   * @param extensions
   *          A List of the names of the extensions to be loaded.
   * @throws InitializationException
   *           If one of the extensions could not be loaded and initialized.
   */
  private synchronized void addExtension(List<File> extensions)
      throws InitializationException {
    // First add the Jar files to the class loader.
    List<JarFile> jars = new LinkedList<>();
    for (File extension : extensions) {
      if (jarFiles.contains(extension)) {
        // Skip this file as it is already loaded.
        continue;
      }

      // Attempt to load it.
      jars.add(loadJarFile(extension));

      // Register the Jar file with the class loader.
      try {
        loader.addJarFile(extension);
      } catch (Exception e) {
        logger.traceException(e);

        LocalizableMessage message = ERR_ADMIN_CANNOT_OPEN_JAR_FILE
            .get(extension.getName(), extension.getParent(), stackTraceToSingleLineString(e));
        throw new InitializationException(message);
      }
      jarFiles.add(extension);
    }

    // Now forcefully load the configuration definition classes.
    for (JarFile jar : jars) {
      initializeExtension(jar);
    }
  }



  /**
   * Prints out all information about extensions.
   *
   * @return a String instance representing all information about extensions;
   *         <code>null</code> if there is no information available.
   */
  public String printExtensionInformation() {
    File extensionsPath = buildExtensionPath(DirectoryServer.getServerRoot());

    List<File> extensions = new ArrayList<>();
    if (extensionsPath.exists() && extensionsPath.isDirectory()) {
      extensions.addAll(listFiles(extensionsPath));
    }

    File instanceExtensionsPath = buildExtensionPath(DirectoryServer.getInstanceRoot());
    if (!extensionsPath.getAbsolutePath().equals(instanceExtensionsPath.getAbsolutePath())) {
      extensions.addAll(listFiles(instanceExtensionsPath));
    }

    if ( extensions.isEmpty() ) {
      return null;
    }

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    PrintStream ps = new PrintStream(baos);
    // prints:
    // --
    //            Name                 Build number         Revision number
    ps.printf("--%s           %-20s %-20s %-20s%s",
              EOL,
              "Name",
              "Build number",
              "Revision number",
              EOL);

    for(File extension : extensions) {
      printExtensionDetails(ps, extension);
    }

    return baos.toString();
  }

  private List<File> listFiles(File path){
    if (path.exists() && path.isDirectory()) {
      return Arrays.asList(path.listFiles(new FileFilter() {
        public boolean accept(File pathname) {
          // only files with names ending with ".jar"
          return pathname.isFile() && pathname.getName().endsWith(".jar");
        }
      }));
    }
    return Collections.emptyList();
  }

  private void printExtensionDetails(PrintStream ps, File extension) {
    // retrieve MANIFEST entry and display name, build number and revision number
    try {
      JarFile jarFile = new JarFile(extension);
      JarEntry entry = jarFile.getJarEntry("admin/" + EXTENSION_MANIFEST);
      if (entry == null) {
        return;
      }

      String[] information = getBuildInformation(jarFile);

      ps.append("Extension: ");
      boolean addBlank = false;
      for(String name : information) {
        if ( addBlank ) {
          ps.append(" ");
        } else {
          addBlank = true;
        }
        ps.printf("%-20s", name);
      }
      ps.append(EOL);
    } catch(Exception e) {
      // ignore extra information for this extension
    }
  }


  /**
   * Returns a String array with the following information :
   * <br>index 0: the name of the extension.
   * <br>index 1: the build number of the extension.
   * <br>index 2: the revision number of the extension.
   *
   * @param extension the jar file of the extension
   * @return a String array containing the name, the build number and the revision number
   *         of the extension given in argument
   * @throws java.io.IOException thrown if the jar file has been closed.
   */
  private String[] getBuildInformation(JarFile extension)
      throws IOException {
    String[] result = new String[3];

    // retrieve MANIFEST entry and display name, version and revision
    Manifest manifest = extension.getManifest();

    if ( manifest != null ) {
      Attributes attributes = manifest.getMainAttributes();

      int index = 0;
      for(String name : BUILD_INFORMATION_ATTRIBUTE_NAMES) {
        String value = attributes.getValue(name);
        if ( value == null ) {
          value = "<unknown>";
        }
        result[index++] = value;
      }
    }

    return result;
  }



  /**
   * Put extensions jars into the class loader and load all configuration definition classes in that they contain.
   * @param extensionsPath Indicates where extensions are located.
   *
   * @throws InitializationException
   *           If the extensions folder could not be accessed or if a extension jar file could not be accessed or
   *           if one of the configuration definition classes could not be initialized.
   */
  private void initializeAllExtensions(File extensionsPath)
      throws InitializationException {

    try {
      if (!extensionsPath.exists()) {
        // The extensions directory does not exist. This is not a critical problem.
        logger.warn(WARN_ADMIN_NO_EXTENSIONS_DIR, extensionsPath);
        return;
      }

      if (!extensionsPath.isDirectory()) {
        // The extensions directory is not a directory. This is more critical.
        throw new InitializationException(ERR_ADMIN_EXTENSIONS_DIR_NOT_DIRECTORY.get(extensionsPath));
      }

      // Add and initialize the extensions.
      addExtension(listFiles(extensionsPath));
    } catch (InitializationException e) {
      logger.traceException(e);
      throw e;
    } catch (Exception e) {
      logger.traceException(e);

      LocalizableMessage message = ERR_ADMIN_EXTENSIONS_CANNOT_LIST_FILES.get(
          extensionsPath, stackTraceToSingleLineString(e));
      throw new InitializationException(message, e);
    }
  }



  /**
   * Make sure all core configuration definitions are loaded.
   *
   * @throws InitializationException
   *           If the core manifest file could not be read or if one of the configuration definition
   *           classes could not be initialized.
   */
  private void initializeCoreComponents()
      throws InitializationException {
    InputStream is = RootCfgDefn.class.getResourceAsStream("/admin/" + CORE_MANIFEST);

    if (is == null) {
      LocalizableMessage message = ERR_ADMIN_CANNOT_FIND_CORE_MANIFEST.get(CORE_MANIFEST);
      throw new InitializationException(message);
    }

    try {
      loadDefinitionClasses(is);
    } catch (InitializationException e) {
      logger.traceException(e);

      LocalizableMessage message = ERR_CLASS_LOADER_CANNOT_LOAD_CORE.get(CORE_MANIFEST,
          stackTraceToSingleLineString(e));
      throw new InitializationException(message);
    }
  }



  /**
   * Make sure all the configuration definition classes in a extension are loaded.
   *
   * @param jarFile
   *          The extension's Jar file.
   * @throws InitializationException
   *           If the extension jar file could not be accessed or if one of the configuration definition classes
   *           could not be initialized.
   */
  private void initializeExtension(JarFile jarFile)
      throws InitializationException {
    JarEntry entry = jarFile.getJarEntry("admin/" + EXTENSION_MANIFEST);
    if (entry != null) {
      InputStream is;
      try {
        is = jarFile.getInputStream(entry);
      } catch (Exception e) {
        logger.traceException(e);

        LocalizableMessage message = ERR_ADMIN_CANNOT_READ_EXTENSION_MANIFEST.get(EXTENSION_MANIFEST, jarFile.getName(),
            stackTraceToSingleLineString(e));
        throw new InitializationException(message);
      }

      try {
        loadDefinitionClasses(is);
      } catch (InitializationException e) {
        logger.traceException(e);

        LocalizableMessage message = ERR_CLASS_LOADER_CANNOT_LOAD_EXTENSION.get(jarFile.getName(), EXTENSION_MANIFEST,
            stackTraceToSingleLineString(e));
        throw new InitializationException(message);
      }
      logExtensionsBuildInformation(jarFile);
    }
  }



  private void logExtensionsBuildInformation(JarFile jarFile)
  {
    try {
      String[] information = getBuildInformation(jarFile);
      LocalizedLogger extensionsLogger = LocalizedLogger.getLocalizedLogger("org.opends.server.extensions");
      extensionsLogger.info(NOTE_LOG_EXTENSION_INFORMATION, jarFile.getName(), information[1], information[2]);
    } catch(Exception e) {
      // Do not log information for that extension
    }
  }



  /**
   * Forcefully load configuration definition classes named in a manifest file.
   *
   * @param is
   *          The manifest file input stream.
   * @throws InitializationException
   *           If the definition classes could not be loaded and initialized.
   */
  private void loadDefinitionClasses(InputStream is)
      throws InitializationException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(is));
    List<AbstractManagedObjectDefinition<?, ?>> definitions = new LinkedList<>();
    while (true) {
      String className;
      try {
        className = reader.readLine();
      } catch (IOException e) {
        throw new InitializationException(
            ERR_CLASS_LOADER_CANNOT_READ_MANIFEST_FILE.get(e.getMessage()), e);
      }

      // Break out when the end of the manifest is reached.
      if (className == null) {
        break;
      }

      // Skip blank lines.
      className = className.trim();
      if (className.length() == 0) {
        continue;
      }

      // Skip lines beginning with #.
      if (className.startsWith("#")) {
        continue;
      }

      logger.trace("Loading class " + className);

      // Load the class and get an instance of it if it is a definition.
      Class<?> theClass;
      try {
        theClass = Class.forName(className, true, loader);
      } catch (Exception e) {
        throw new InitializationException(ERR_CLASS_LOADER_CANNOT_LOAD_CLASS.get(className, e.getMessage()), e);
      }
      if (AbstractManagedObjectDefinition.class.isAssignableFrom(theClass)) {
        // We need to instantiate it using its getInstance() static method.
        Method method;
        try {
          method = theClass.getMethod("getInstance");
        } catch (Exception e) {
          throw new InitializationException(
              ERR_CLASS_LOADER_CANNOT_FIND_GET_INSTANCE_METHOD.get(className, e.getMessage()), e);
        }

        // Get the definition instance.
        AbstractManagedObjectDefinition<?, ?> d;
        try {
          d = (AbstractManagedObjectDefinition<?, ?>) method.invoke(null);
        } catch (Exception e) {
          throw new InitializationException(
              ERR_CLASS_LOADER_CANNOT_INVOKE_GET_INSTANCE_METHOD.get(className, e.getMessage()), e);
        }
        definitions.add(d);
      }
    }

    // Initialize any definitions that were loaded.
    for (AbstractManagedObjectDefinition<?, ?> d : definitions) {
      try {
        d.initialize();
      } catch (Exception e) {
        throw new InitializationException(
            ERR_CLASS_LOADER_CANNOT_INITIALIZE_DEFN.get(d.getName(), d.getClass().getName(), e.getMessage()), e);
      }
    }
  }



  /**
   * Load the named Jar file.
   *
   * @param jar
   *          The name of the Jar file to load.
   * @return Returns the loaded Jar file.
   * @throws InitializationException
   *           If the Jar file could not be loaded.
   */
  private JarFile loadJarFile(File jar)
      throws InitializationException {
    JarFile jarFile;

    try {
      // Load the extension jar file.
      jarFile = new JarFile(jar);
    } catch (Exception e) {
      logger.traceException(e);

      LocalizableMessage message = ERR_ADMIN_CANNOT_OPEN_JAR_FILE.get(
          jar.getName(), jar.getParent(), stackTraceToSingleLineString(e));
      throw new InitializationException(message);
    }
    return jarFile;
  }

}