package util.logger;

import java.io.OutputStream;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;


/**
 * A class that handles a logger. 
 * This class does not propagate LogRecords to parent Loggers, so if the
 * user wants to set parents or even more complex instructions, he/she
 * should call getLogger() to do so.
 * It sets a console handler as a default handler.
 * 
 * By default, the logger starts at ALL level so any type of message is logged.
 * 
 * Note that the user does not need to use any other class in this package
 * except this one to manage the logger
 * 
 * @author Henrique Moraes
 */
public class LoggerManager {
    /**
     * This logger serves as a quick reference in case the user
     * wants to log a message in one line of code
     * The logger used was initialized with this class' name
     */
    public static final Logger DEFAULT_LOGGER =
            Logger.getLogger(LoggerManager.class.getName());

    private static final String LOG_EXT = ".log";
    public static final String DEFAULT_FILE_NAME = "Logger";

    private Logger myLogger;
    private IVoogaHandler myDefaultHandler = new HandlerConsole();
    private Level myDefaultLevel = Level.ALL;

    /**
     * Constructor
     * Sets a logger using reflection to find the name of the calling class
     * The Logger is initialized with the name of the calling class
     * By default, a console handler is set
     */
    public LoggerManager () {
        initializeLogger(LoggerReflection.getCallerClassName());
    }

    /**
     * Constructor.
     * Sets a logger according to the given class name
     */
    public LoggerManager (String loggerName) {
        initializeLogger(loggerName);
    }

    /**
     * Initializes a logger with default parameters of this manager
     * 
     * @param loggerName Name of the logger to initialize
     */
    private void initializeLogger (String loggerName) {
        myLogger = Logger.getLogger(loggerName);
        myLogger.setUseParentHandlers(false);
        myLogger.setLevel(myDefaultLevel);
        addHandler(myDefaultHandler);
    }

    /**
     * Adds a handler to the logger and sets it to the logger level
     * All add handler methods eventually pass through this method
     * Can be used to set customized handlers for the logger in case
     * the user wants to extend the design
     * 
     * @param handlerType the type of handler to be added
     */
    public void addHandler (IVoogaHandler hand) {
        Handler handler = hand.getHandler();
        handler.setLevel(myLogger.getLevel());
        myLogger.addHandler(handler);
    }

    /**
     * Adds a memory handler to the logger depending on given handler and
     * constraints. A memory handler pushes all log records after a message of
     * the specified threshold level is logged
     * This API was designed to be able to combine any other handler to the
     * memoryHandler
     * WARNING the type of handler added will have level INFO.
     * Once it is set, its level cannot be changed. If the user wishes to set
     * the handler from memory, he should set it manually and call the regular
     * addHandler()
     * 
     * @param handler the type of handler to have records pushed to
     * @param size Number of maximum records this handler will maintain
     * @param pushLevel push to handler as soon as a message of the given
     *        level is issued
     */
    public void addMemoryHandler (IVoogaHandler handler, int size, Level pushLevel) {
        addHandler(new HandlerMemory(handler, size, pushLevel));
    }

    /**
     * Adds a memory handler to the logger depending on given handler and
     * constraints. A memory handler pushes all log records after a message of
     * the specified threshold level is logged
     * This API was designed to be able to combine any other handler to the
     * memoryHandler
     * WARNING the type of handler added will have level INFO.
     * Once it is set, its level cannot be changed. If the user wishes to set
     * the handler from memory, he should set it manually and call the regular
     * addHandler()
     * 
     * @param handler the type of handler to have records pushed to
     */
    public void addMemoryHandler (IVoogaHandler handler) {
        HandlerMemory memory = new HandlerMemory();
        memory.setHandler(handler);
        addHandler(memory);
    }

    /**
     * 
     * Adds a handler that sends log records to the Console
     */
    public void addConsoleHandler () {
        addHandler(new HandlerConsole());
    }

    /**
     * 
     * Adds a handler that records messages in a txt file with a
     * default file name
     */
    public void addTxtHandler () {
        addHandler(new HandlerTxt());
    }

    /**
     * 
     * Adds a handler that records messages in a txt file
     * 
     * @param fileName Name of the file to have records written to
     */
    public void addTxtHandler (String fileName) {
        addHandler(new HandlerTxt(fileName));
    }

    /**
     * 
     * Adds a handler that records messages in a file with user-defined extension
     * 
     * @param fileName Name of the file to have records written to
     * @param ext The extension of the file
     */
    public void addCustomExtensionFileHandler (String fileName, String ext) {
        addHandler(new HandlerTxt(fileName, ext));
    }

    /**
     * 
     * Adds a handler that records messages in a .log file
     * 
     * @param fileName Name of the file to have records written to
     */
    public void addLogHandler (String fileName) {
        addCustomExtensionFileHandler(fileName, LOG_EXT);
    }

    /**
     * 
     * Adds a handler that records messages in an XML file
     * 
     * @param fileName Name of the file to have records written to
     */
    public void addXMLHandler (String fileName) {
        addHandler(new HandlerXML(fileName));
    }

    /**
     * 
     * Adds a handler that records messages in an XML file
     */
    public void addXMLHandler () {
        addHandler(new HandlerXML());
    }

    /**
     * 
     * Adds a handler that sends log records across a given stream
     * 
     * @param out Outputstream that this handler should write to
     */
    public void addStreamHandler (OutputStream out) {
        addHandler(new HandlerStream(out));
    }

    /**
     * 
     * Adds a handler that sends log records across a given stream
     * If no stream is given, the manager chooses System.out by default
     */
    public void addStreamHandler () {
        addHandler(new HandlerStream());
    }

    /**
     * 
     * Adds a handler that sends log records through a given socket
     * 
     * @param host string with the name of the host of this connection
     * @param port number of the port to be used
     */
    public void addSocketHandler (String host, int port) {
        addHandler(new HandlerSocket(host, port));
    }

    /**
     * 
     * Adds a handler that sends log records via e-mail
     * 
     * @param from Address from which the e-mail is sent
     * @param to String array with recipients to send e-mail to
     * @param server Server address
     * @param subject Subject of e-mail
     * @param message Text in e-mail
     */
    public void addMailHandler (String from, String[] to,
                                String server, String subject, String message) {
        addHandler(new HandlerMail(from, to, server, subject, message));
    }

    /**
     * Sets the level of the logger and all its handlers
     * 
     * @param level
     */
    public void setLevel (Level level) {
        myLogger.setLevel(level);
        for (Handler h : myLogger.getHandlers()) {
            h.setLevel(level);
        }
    }

    /**
     * Logs a message on the logger of this manager
     * 
     * @param level the level of the LogRecord
     * @param message The message to log
     */
    public void log (Level level, String message) {
        LogRecord record = new LogRecord(level, message);
        record.setSourceClassName(LoggerReflection.getCallerClassName());
        record.setSourceMethodName(LoggerReflection.getCallerMethodName());
        myLogger.log(record);
    }

    /**
     * Logs a FINER level message on the logger of this manager
     * 
     * @param message The message to log
     */
    public void finer (String message) {
        log(Level.FINER, message);
    }

    /**
     * Logs a INFO level message on the logger of this manager
     * 
     * @param message The message to log
     */
    public void info (String message) {
        log(Level.INFO, message);
    }

    /**
     * Logs a WARNING level message on the logger of this manager
     * 
     * @param message The message to log
     */
    public void warning (String message) {
        log(Level.WARNING, message);
    }

    /**
     * Logs a SEVERE level message on the logger of this manager
     * 
     * @param message The message to log
     */
    public void severe (String message) {
        log(Level.SEVERE, message);
    }

    /**
     * Gets the logger of this manager in case the user wants to 
     * handle it for more complex instructions
     * @return The logger associated with this Manager
     */
    public Logger getLogger () {
        return myLogger;
    }

    /**
     * Removes all handlers from the current logger of this manager
     */
    public void clearHandlers () {
        for (Handler h : myLogger.getHandlers()) {
            myLogger.removeHandler(h);
        }
    }

}