/*
 * 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.juli.logging;

import java.lang.reflect.Constructor;
import java.nio.file.FileSystems;
import java.util.ServiceLoader;
import java.util.logging.LogManager;

import aQute.bnd.annotation.spi.ServiceConsumer;

/**
 * This is a modified LogFactory that uses a simple {@link ServiceLoader} based discovery mechanism with a default of
 * using JDK based logging. An implementation that uses the full Commons Logging discovery mechanism is available as
 * part of the Tomcat extras download.
 * <p>
 * Why? It is an attempt to strike a balance between simpler code (no discovery) and providing flexibility -
 * particularly for those projects that embed Tomcat or some of Tomcat's components - is an alternative logging
 * implementation is desired.
 * <p>
 * Note that this implementation is not just a wrapper around JDK logging (like the original commons-logging impl). It
 * adds 2 features - a simpler configuration (which is in fact a subset of log4j.properties) and a formatter that is
 * less ugly.
 * <p>
 * The removal of 'abstract' preserves binary backward compatibility. It is possible to preserve the abstract - and
 * introduce another (hardcoded) factory - but I see no benefit.
 * <p>
 * Since this class is not intended to be extended - all protected methods are removed. This can be changed - but again,
 * there is little value in keeping dead code. Just take a quick look at the removed code ( and it's complexity).
 * <p>
 * Original comment:
 * <p>
 * Factory for creating {@link Log} instances, with discovery and configuration features similar to that employed by
 * standard Java APIs such as JAXP.
 * </p>
 * <p>
 * <strong>IMPLEMENTATION NOTE</strong> - This implementation is heavily based on the SAXParserFactory and
 * DocumentBuilderFactory implementations (corresponding to the JAXP pluggability APIs) found in Apache Xerces.
 * </p>
 *
 * @author Craig R. McClanahan
 * @author Costin Manolache
 * @author Richard A. Sitze
 */
@ServiceConsumer(value = Log.class)
public class LogFactory {

    private static final LogFactory singleton = new LogFactory();

    private final Constructor<? extends Log> discoveredLogConstructor;

    /**
     * Private constructor that is not available for public use.
     */
    private LogFactory() {
        /*
         * Work-around known a JRE bug. https://bugs.openjdk.java.net/browse/JDK-8194653
         *
         * Preload the default file system. No performance impact as we need to load the default file system anyway.
         * Just do it earlier to avoid the potential deadlock.
         *
         * This can be removed once the oldest JRE supported by Tomcat includes a fix.
         */
        FileSystems.getDefault();

        // Look via a ServiceLoader for a Log implementation that has a
        // constructor taking the String name.
        ServiceLoader<Log> logLoader = ServiceLoader.load(Log.class);
        Constructor<? extends Log> m = null;
        for (Log log : logLoader) {
            Class<? extends Log> c = log.getClass();
            try {
                m = c.getConstructor(String.class);
                break;
            } catch (NoSuchMethodException | SecurityException e) {
                throw new Error(e);
            }
        }
        discoveredLogConstructor = m;
    }


    // --------------------------------------------------------- Public Methods

    // only those 2 methods need to change to use a different direct logger.

    /**
     * <p>
     * Construct (if necessary) and return a <code>Log</code> instance, using the factory's current set of configuration
     * attributes.
     * </p>
     * <p>
     * <strong>NOTE</strong> - Depending upon the implementation of the <code>LogFactory</code> you are using, the
     * <code>Log</code> instance you are returned may or may not be local to the current application, and may or may not
     * be returned again on a subsequent call with the same name argument.
     * </p>
     *
     * @param name Logical name of the <code>Log</code> instance to be returned (the meaning of this name is only known
     *                 to the underlying logging implementation that is being wrapped)
     *
     * @return A log instance with the requested name
     *
     * @exception LogConfigurationException if a suitable <code>Log</code> instance cannot be returned
     */
    public Log getInstance(String name) throws LogConfigurationException {
        if (discoveredLogConstructor == null) {
            return DirectJDKLog.getInstance(name);
        }

        try {
            return discoveredLogConstructor.newInstance(name);
        } catch (ReflectiveOperationException | IllegalArgumentException e) {
            throw new LogConfigurationException(e);
        }
    }


    /**
     * Convenience method to derive a name from the specified class and call <code>getInstance(String)</code> with it.
     *
     * @param clazz Class for which a suitable Log name will be derived
     *
     * @return A log instance with a name of clazz.getName()
     *
     * @exception LogConfigurationException if a suitable <code>Log</code> instance cannot be returned
     */
    public Log getInstance(Class<?> clazz) throws LogConfigurationException {
        return getInstance(clazz.getName());
    }


    // ------------------------------------------------------- Static Variables


    // --------------------------------------------------------- Static Methods


    /**
     * <p>
     * Construct (if necessary) and return a <code>LogFactory</code> instance, using the following ordered lookup
     * procedure to determine the name of the implementation class to be loaded.
     * </p>
     * <ul>
     * <li>The <code>org.apache.commons.logging.LogFactory</code> system property.</li>
     * <li>The JDK 1.3 Service Discovery mechanism</li>
     * <li>Use the properties file <code>commons-logging.properties</code> file, if found in the class path of this
     * class. The configuration file is in standard <code>java.util.Properties</code> format and contains the fully
     * qualified name of the implementation class with the key being the system property defined above.</li>
     * <li>Fall back to a default implementation class
     * (<code>org.apache.commons.logging.impl.LogFactoryImpl</code>).</li>
     * </ul>
     * <p>
     * <em>NOTE</em> - If the properties file method of identifying the <code>LogFactory</code> implementation class is
     * utilized, all of the properties defined in this file will be set as configuration attributes on the corresponding
     * <code>LogFactory</code> instance.
     * </p>
     *
     * @return The singleton LogFactory instance
     *
     * @exception LogConfigurationException if the implementation class is not available or cannot be instantiated.
     */
    public static LogFactory getFactory() throws LogConfigurationException {
        return singleton;
    }


    /**
     * Convenience method to return a named logger, without the application having to care about factories.
     *
     * @param clazz Class from which a log name will be derived
     *
     * @return A log instance with a name of clazz.getName()
     *
     * @exception LogConfigurationException if a suitable <code>Log</code> instance cannot be returned
     */
    public static Log getLog(Class<?> clazz) throws LogConfigurationException {
        return getFactory().getInstance(clazz);
    }


    /**
     * Convenience method to return a named logger, without the application having to care about factories.
     *
     * @param name Logical name of the <code>Log</code> instance to be returned (the meaning of this name is only known
     *                 to the underlying logging implementation that is being wrapped)
     *
     * @return A log instance with the requested name
     *
     * @exception LogConfigurationException if a suitable <code>Log</code> instance cannot be returned
     */
    public static Log getLog(String name) throws LogConfigurationException {
        return getFactory().getInstance(name);
    }


    /**
     * Release any internal references to previously created {@link LogFactory} instances that have been associated with
     * the specified class loader (if any), after calling the instance method <code>release()</code> on each of them.
     *
     * @param classLoader ClassLoader for which to release the LogFactory
     */
    public static void release(ClassLoader classLoader) {
        // JULI's log manager looks at the current classLoader so there is no
        // need to use the passed in classLoader, the default implementation
        // does not so call reset in that case will break things
        if (!LogManager.getLogManager().getClass().getName().equals("java.util.logging.LogManager")) {
            LogManager.getLogManager().reset();
        }
    }
}