/*
 * 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.
 */
#ifndef _DECAF_UTIL_LOGGING_LOGGER_H_
#define _DECAF_UTIL_LOGGING_LOGGER_H_

#include <decaf/util/logging/LoggerCommon.h>
#include <decaf/util/logging/LogRecord.h>
#include <decaf/lang/exceptions/IllegalArgumentException.h>
#include <decaf/util/Config.h>

#include <list>
#include <string>
#include <stdarg.h>

namespace decaf{
namespace util{
namespace logging{

    class Handler;
    class Filter;

    class DECAF_API Logger
    {
    private:

        // The name of this Logger
        std::string name;

        // The Parent of this Logger
        Logger* parent;

        // list of Handlers owned by this logger
        std::list<Handler*> handlers;

        // Filter used by this Logger
        Filter* filter;

        // The Log Level of this Logger
        Level level;

        // Using Parent Handlers?
        bool useParentHandlers;

    public:

        /**
         * Creates a new instance of the Logger with the given name
         * and assign it the given parent logger.
         * <p>
         * The logger will be initially configured with a null Level
         * and with useParentHandlers true.
         * @param name - A name for the logger. This should be a
         * dot-separated name and should normally be based on the package
         * name or class name of the subsystem, such as java.net or
         * javax.swing. It may be null for anonymous Loggers.
         * @param parent logger that is this one's parent
         */
        Logger( const std::string& name, Logger* parent );

        virtual ~Logger();

        /**
         * Gets the name of this Logger
         * @return logger name
         */
        virtual const std::string& getName(void) const {
            return name;
        }

        /**
         * Add a log Handler to receive logging messages.
         * <p>
         * By default, Loggers also send their output to their parent logger.
         * Typically the root Logger is configured with a set of Handlers
         * that essentially act as default handlers for all loggers.
         *
         * @param handler A Logging Handler
         * #throws IllegalArgumentException
         */
        virtual void addHandler( Handler* handler )
            throw ( lang::exceptions::IllegalArgumentException );

        /**
         * Removes the specified Handler and destroys it
         * <p>
         * Returns silently if the given Handler is not found.
         * @param handler The Handler to remove
         */
        virtual void removeHandler( Handler* handler );

        /**
         * Gets a vector containing all the handlers that this class
         * has been assigned to use.
         * @returns a list of handlers that are used by this logger
         */
        // virtual const std::list<Handler*>& getHandlers(void) const;

        /**
         * Set a filter to control output on this Logger.
         * <p>
         * After passing the initial "level" check, the Logger will call
         * this Filter to check if a log record should really be published.
         * <p>
         * The caller releases ownership of this filter to this logger
         * @param filter to use, can be null
         */
        virtual void setFilter( Filter* filter );

        /**
         * Gets the Filter object that this class is using.
         * @return the Filter in use, can be null
         */
        virtual const Filter* getFilter() const {
            return filter;
        }

        /**
         * Get the log Level that has been specified for this Logger. The
         * result may be the Null level, which means that this logger's
         * effective level will be inherited from its parent.
         * @return the level that is currently set
         */
        virtual Level getLevel() const {
            return level;
        }

        /**
         * Set the log level specifying which message levels will be logged
         * by this logger. Message levels lower than this value will be
         * discarded. The level value Level.OFF can be used to turn off
         * logging.
         * <p>
         * If the new level is the Null Level, it means that this node
         * should inherit its level from its nearest ancestor with a
         * specific (non-null) level value.
         * @param level new Level value
         */
        virtual void setLevel( Level level ) {
            this->level = level;
        }

        /**
         * Discover whether or not this logger is sending its output to
         * its parent logger.
         * @return true if using Parent Handlers
         */
        virtual bool getUseParentHandlers() const {
            return useParentHandlers;
        }

        /**
         * pecify whether or not this logger should send its output to it's
         * parent Logger. This means that any LogRecords will also be
         * written to the parent's Handlers, and potentially to its parent,
         * recursively up the namespace.
         * @param value True is output is to be writen to the parent
         */
        virtual void setUseParentHandlers( bool value ) {
            this->useParentHandlers = value;
        }

        /**
         * Logs an Block Enter message
         * <p>
         * This is a convenience method that is used to tag a block enter, a
         * log record with the class name function name and the string
         * Entering is logged at the DEBUG log level.
         * @param blockName source block name
         * @param file source file name
         * @param line source line name
         */
        virtual void entry( const std::string& blockName,
                            const std::string& file,
                            const int line );

        /**
         * Logs an Block Exit message
         * <p>
         * This is a convenience method that is used to tag a block exit, a
         * log record with the class name function name and the string
         * Exiting is logged at the DEBUG log level.
         * @param blockName source block name
         * @param file source file name
         * @param line source line name
         */
        virtual void exit( const std::string& blockName,
                           const std::string& file,
                           const int line );

        /**
         * Log a Debug Level Log
         * <p>
         * If the logger is currently enabled for the DEBUG message level
         * then the given message is forwarded to all the registered output
         * Handler objects.
         * @param file the file name where the log was generated
         * @param line the line number where the log was generated
         * @param functionName name of the function that logged this
         * @param message the message to log
         */
        virtual void debug( const std::string& file,
                            const int line,
                            const std::string functionName,
                            const std::string& message );

        /**
         * Log a info Level Log
         * <p>
         * If the logger is currently enabled for the info message level
         * then the given message is forwarded to all the registered output
         * Handler objects.
         *
         * @param file the file name where the log was generated
         * @param line the line number where the log was generated
         * @param functionName name of the function that logged this
         * @param message the message to log
         */
        virtual void info( const std::string& file,
                           const int line,
                           const std::string functionName,
                           const std::string& message );

        /**
         * Log a warn Level Log
         * <p>
         * If the logger is currently enabled for the warn message level
         * then the given message is forwarded to all the registered output
         * Handler objects.
         * @param file the file name where the log was generated
         * @param line the line number where the log was generated
         * @param functionName name of the function that logged this
         * @param message the message to log
         */
        virtual void warn( const std::string& file,
                           const int line,
                           const std::string functionName,
                           const std::string& message );

        /**
         * Log a error Level Log
         * <p>
         * If the logger is currently enabled for the error message level
         * then the given message is forwarded to all the registered output
         * Handler objects.
         * @param file the file name where the log was generated
         * @param line the line number where the log was generated
         * @param fnctionName name of the function that logged this
         * @param message the message to log
         */
        virtual void error( const std::string& file,
                            const int line,
                            const std::string fnctionName,
                            const std::string& message );

        /**
         * Log a fatal Level Log
         * <p>
         * If the logger is currently enabled for the fatal message level
         * then the given message is forwarded to all the registered output
         * Handler objects.
         * @param file the file name where the log was generated
         * @param line the line number where the log was generated
         * @param fnctionName name of the function that logged this
         * @param message the message to log
         */
        virtual void fatal( const std::string& file,
                            const int line,
                            const std::string functionName,
                            const std::string& message );

        /**
         * Log a Throw Message
         * <p>
         * If the logger is currently enabled for the Throwing message level
         * then the given message is forwarded to all the registered output
         * Handler objects.
         * @param file the file name where the log was generated
         * @param line the line number where the log was generated
         * @param fnctionName name of the function that logged this
         * @param message the message to log
        virtual void throwing( const std::string& file,
                               const int line,
                               const std::string fnctionName,
                               const std::string& message );
         */

        /**
         * Check if a message of the given level would actually be logged
         * by this logger. This check is based on the Loggers effective
         * level, which may be inherited from its parent.
         * @param level - a message logging level
         * @returns true if the given message level is currently being logged.
         */
        virtual bool isLoggable( Level level ) const;

        /**
         * Log a LogRecord.
         * All the other logging methods in this class call through this
         * method to actually perform any logging. Subclasses can override
         * this single method to capture all log activity.
         * @param record - the LogRecord to be published
         */
        virtual void log( LogRecord& record );

        /**
         * Log a message, with no arguments.
         * <p>
         * If the logger is currently enabled for the given message level
         * then the given message is forwarded to all the registered output
         * Handler objects
         * @param level the Level to log at
         * @param message the message to log
         */
        virtual void log( Level level, const std::string& message );

        /**
         * Log a message, with the list of params that is formatted into
         * the message string.
         * <p>
         * If the logger is currently enabled for the given message level
         * then the given message is forwarded to all the registered output
         * Handler objects
         * @param level the Level to log at
         * @param file the message to log
         * @param line the line in the file
         * @param variable length arguement to format the message string.
         */
        virtual void log( Level level,
                          const std::string& file,
                          const int line,
                          const std::string& message, ... );

        /**
         * Log a message, with associated Throwable information.
         * If the logger is currently enabled for the given message level
         * then the given arguments are stored in a LogRecord which is
         * forwarded to all registered output handlers.
         * Note that the thrown argument is stored in the LogRecord thrown
         * property, rather than the LogRecord parameters property. Thus is
         * it processed specially by output Formatters and is not treated
         * as a formatting parameter to the LogRecord message property.
         * @param level the Level to log at
         * @param file File that the message was logged in
         * @param line the line number where the message was logged at.
         * @param ex the Exception to log
         */
        virtual void log( Level level,
                          const std::string& file,
                          const int line,
                          const std::string& message,
                          lang::Exception& ex );

    public:

        /**
         * Creates an anonymous logger
         * <p>
         * The newly created Logger is not registered in the LogManager
         * namespace. There will be no access checks on updates to the
         * logger.
         * Even although the new logger is anonymous, it is configured to
         * have the root logger ("") as its parent. This means that by
         * default it inherits its effective level and handlers from the
         * root logger.
         * <p>
         * The caller is responsible for destroying the returned logger.
         * @return Newly created anonymous logger
         */
        static Logger* getAnonymousLogger();

        /**
         * Find or create a logger for a named subsystem. If a logger has
         * already been created with the given name it is returned.
         * Otherwise a new logger is created.
         * <p>
         * If a new logger is created its log level will be configured based
         * on the LogManager and it will configured to also send logging
         * output to its parent loggers Handlers. It will be registered in
         * the LogManager global namespace.
         * @param name - A name for the logger. This should be a
         * dot-separated name and should normally be based on the package
         * name or class name of the subsystem, such as cms or
         * activemq.core.ActiveMQConnection
         * @return a suitable logger.
         */
        static Logger* getLogger( const std::string& name );

    };

}}}

#endif /*_DECAF_UTIL_LOGGING_LOGGER_H_*/