package org.andromda.core.common;

import java.io.InputStream;
import java.net.URL;
import org.andromda.core.configuration.Namespaces;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;

/**
 * This is the logger used to write <em>AndroMDA</em> prefixed messages so that our informational logging is nice
 * looking.
 *
 * @author <a href="http://www.mbohlen.de">Matthias Bohlen </a>
 * @author Chad Brandon
 * @author Bob Fields
 * @since 26.11.2003
 */
public class AndroMDALogger
{
    /**
     * The default name to give the logger (if one isn't set)
     */
    private static final String DEFAULT_LOGGER_NAME = "AndroMDA";
    private static Logger logger = Logger.getLogger(DEFAULT_LOGGER_NAME);

    /**
     * Configures logging for the AndroMDA application from the the xml resource "log4j.xml" found within the same
     * package as this class.
     */
    public static void initialize()
    {
        String defaultConfiguration = "log4j.xml";
        URL url = null;
        final String configuration = loggingConfigurationUri;
        if (StringUtils.isNotBlank(configuration))
        {
            try
            {
                url = new URL(configuration);
                InputStream stream = url.openStream();
                stream.close();

                configure(url);
                logger.info("Logging configured from external source --> '" + configuration + '\'');
            }
            catch (Throwable throwable)
            {
                url = AndroMDALogger.class.getResource(defaultConfiguration);
                configure(url);
                logger.warn("Invalid logging configuration uri --> '" + configuration + '\'');
            }
        }
        if (url == null)
        {
            url = AndroMDALogger.class.getResource(defaultConfiguration);
            configure(url);
        }
        if (url == null)
        {
            throw new RuntimeException(
                "Could not find default logging configuration file '" + defaultConfiguration + '\'');
        }
    }

    /**
     * The URI to an external logging configuration file.
     */
    private static String loggingConfigurationUri = null;

    /**
     * Sets the URI to an external logging configuration file. This will override the default log4j.xml.
     *
     * @param loggingConfigurationUri the URI to the logging configuration file.
     */
    public static void setLoggingConfigurationUri(final String loggingConfigurationUri)
    {
        AndroMDALogger.loggingConfigurationUri = loggingConfigurationUri;
    }

    /**
     * Configures the Logger from the passed in logConfigurationXml
     *
     * @param logConfigurationXml
     */
    protected static void configure(final URL logConfigurationXml)
    {
        try
        {
            DOMConfigurator.configure(logConfigurationXml);
        }
        catch (Exception ex)
        {
            //noinspection UseOfSystemOutOrSystemErr
            System.err.println(
                "Unable to initialize logging system " + "with configuration file '" + logConfigurationXml +
                "' --> using basic configuration.");
            BasicConfigurator.configure();
        }
    }

    /**
     * Retrieves the namespace logger (if one is available) otherwise returns the root logger.
     *
     * @param namespaceName the name of the namespace for which we'll retrieve the logger instance.
     * @return the namespace or root logger instance.
     */
    public static Logger getNamespaceLogger(final String namespaceName)
    {
        Logger logger;
        if (namespaceName != null && !Namespaces.DEFAULT.equals(namespaceName))
        {
            logger = Logger.getLogger(getNamespaceLoggerName(namespaceName));
        }
        else
        {
            logger = Logger.getRootLogger();
        }
        return logger;
    }

    /**
     * Gets the name of the logger.
     *
     * @param namespace the name of the namespace for which this logger is used.
     * @return the logger name.
     */
    public static String getNamespaceLoggerName(final String namespace)
    {
        return "org.andromda.namespaces." + namespace;
    }

    /**
     * Gets the name of the file to which namespace logging output will be written.
     *
     * @param namespace the name of the namespace for which this logger is used.
     * @return the namespace logging file name.
     */
    public static String getNamespaceLogFileName(final String namespace)
    {
        return "andromda-" + namespace + ".log";
    }

    /**
     * Allows us to add a suffix to the logger name.
     *
     * @param suffix the suffix to append to the logger name.
     */
    public static void setSuffix(final String suffix)
    {
        logger = getSuffixLogger(suffix);
    }

    /**
     * Gets a logger with suffixed name
     * @param suffix the suffix to append to the logger name.
     * @return Logger instance
     */
    public static Logger getSuffixLogger(final String suffix)
    {
        return Logger.getLogger(DEFAULT_LOGGER_NAME + ':' + suffix);
    }

    /**
     * Returns true if the logger is debug enabled. Use before AndroMDALogger.debug calls
     * where String concatenation or object manipulation in the method call occurs.
     * @return true if the underlying logger is debug enabled
     */
    public static boolean isDebugEnabled()
    {
        return logger.isDebugEnabled();
    }

    /**
     * Resets the logger to the default name.
     */
    public static void reset()
    {
        logger = Logger.getLogger(DEFAULT_LOGGER_NAME);
    }

    /**
     * Shuts down the logger and releases any resources.
     */
    public static void shutdown()
    {
        LogManager.shutdown();
    }

    /**
     * @param object
     */
    public static void debug(Object object)
    {
        logger.debug(object);
    }

    /**
     * @param object
     */
    public static void info(Object object)
    {
        logger.info(object);
    }

    /**
     * @param object
     */
    public static void warn(Object object)
    {
        logger.warn(object);
    }

    /**
     * @param object
     */
    public static void error(Object object)
    {
        logger.error(object);
    }
}