/*

  * This file is part of AceLogger.

  * 

  * AceLogger is free software: you can redistribute it and/or modify it under the terms of the GNU

  * Lesser General Public License as published by the Free Software Foundation, either version 3 of

  * the License, or (at your option) any later version.

  * 

  * AceLogger is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without

  * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

  * Lesser General Public License for more details.

  * 

  * You should have received a copy of the GNU Lesser General Public License along with AceLogger.

  * If not, see <http://www.gnu.org/licenses/lgpl-3.0.html>.

  */

 package net.sourceforge.acelogger.factory;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import net.sourceforge.acelogger.Logger;

 import net.sourceforge.acelogger.constants.LoggerConstants;

 import net.sourceforge.acelogger.execution.LogController;

 import net.sourceforge.acelogger.location.resolver.CodeFrameResolver;

 import net.sourceforge.acelogger.location.resolver.InternalCodeFrameResolver;

 /**

  * Factory for managing instances of configured loggers.

  * 

  * @author Zardi (https://sourceforge.net/users/daniel_zardi)

  * @version 1.0.0

  * @since 1.0.0

  */

 public final class LoggerFactory {

         /**

          * A instance of this class (the only one).

          */

         private static final LoggerFactory INSTANCE = new LoggerFactory();

         /**

          * Used when no configured logger is found for a given identifier.

          */

         private Logger defaultLogger;

         /**

          * Maps each logger manager to a unique identifier.

          */

         private final Map<String, Logger> registeredLoggers;

         /**

          * The resolver used to determine which class invoked the factory method.

          */

         private CodeFrameResolver resolver;

         /**

          * Creates a new LoggerFactory (This class is a singleton).

          * 

          * @since 1.0.0

          */

         private LoggerFactory() {

                 registeredLoggers = new HashMap<String, Logger>();

                 resolver = new InternalCodeFrameResolver(1);

                 defaultLogger = LoggerConstants.EMPTY;

         }

         /**

          * Obtains a properly configured logger for the given identifier.

          * 

          * @param identifier

          *            The identifier of the intended logger.

          * @return A properly configured logger for the given identifier. If the identifier is not

          *         found, then the default logger is returned.

          * @see LoggerFactory#getDefaultLogger()

          * @since 1.0.0

          */

         public static Logger getLogger(String identifier) {

                 LogController.ensureInitialization();

                 Logger intendedLogger = INSTANCE.registeredLoggers.get(identifier);

                 if (intendedLogger == null) {

                         int lastDotIndex = identifier.lastIndexOf('.');

                         if (lastDotIndex > 0) {

                                 intendedLogger = getLogger(identifier.substring(0, lastDotIndex));

                         } else {

                                 intendedLogger = INSTANCE.defaultLogger;

                         }

                 }

                 return intendedLogger;

         }

         /**

          * Obtains a properly configured logger for the given class.

          * 

          * @param clazz

          *            The class that will generate the logger identifier.

          * @return A properly configured logger for the given identifier. If the identifier is not

          *         found, then the default logger is returned.

          * @see LoggerFactory#getDefaultLogger()

          * @since 1.0.0

          */

         public static Logger getLogger(Class<?> clazz) {

                 return getLogger(clazz.getName());

         }

         /**

          * Obtains a properly configured logger based in the callers class information.

          * 

          * @return A properly configured logger for the given identifier. If the identifier is not

          *         found, then the default logger is returned.

          * @see LoggerFactory#getDefaultLogger()

          * @see CodeFrameResolver#getCodeFrame()

          * @since 1.0.0

          */

         public static Logger getLogger() {

                 String codeFrameQualifiedClassName = INSTANCE.resolver.getCodeFrame().getClassName();

                 return getLogger(codeFrameQualifiedClassName);

         }

         /**

          * Sets the default logger of this factory, the one used when no logger is found for a given

          * identifier.

          * 

          * @param defaultLogger

          *            The logger that will be used as the default one from now.

          * @return The previous default logger.

          * @since 1.0.0

          */

         public static Logger setDefaultLogger(Logger defaultLogger) {

                 LogController.ensureInitialization();

                 Logger previous = INSTANCE.defaultLogger;

                 if (defaultLogger != null) {

                         INSTANCE.defaultLogger = defaultLogger;

                 }

                 return previous;

         }

         /**

          * Returns the default logger of this factory, the one used when no logger is found for a given

          * identifier.

          * 

          * @return The default logger.

          * @since 1.0.0

          */

         public static Logger getDefaultLogger() {

                 LogController.ensureInitialization();

                 return INSTANCE.defaultLogger;

         }

         /**

          * Returns a list of all loggers registered in this factory.

          * 

          * @return A list of loggers.

          * @since 1.0.0

          */

         public static List<Logger> getRegisteredLoggers() {

                 LogController.ensureInitialization();

                 return new ArrayList<Logger>(INSTANCE.registeredLoggers.values());

         }

         /**

          * Registers an appender within this factory. The mapped identifier will be the loggers

          * identifier.

          * 

          * @param logger

          *            The logger to be registered.

          * @return The default logger if there was no previous mapping for the identifier or the

          *         previous configured logger otherwise.

          * @see LoggerFactory#getDefaultLogger()

          * @since 1.0.0

          */

         public static Logger registerLogger(Logger logger) {

                 LogController.ensureInitialization();

                 Logger intendedLogger = null;

                 if (logger != null) {

                         intendedLogger = INSTANCE.registeredLoggers.put(logger.getIdentifier(), logger);

                 }

                 if (intendedLogger == null) {

                         intendedLogger = INSTANCE.defaultLogger;

                 }

                 return intendedLogger;

         }

 }