/*
    * 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;
  
  import net.sourceforge.acelogger.appender.Appender;
  import net.sourceforge.acelogger.constants.AppenderConstants;
  import net.sourceforge.acelogger.constants.LevelFilterConstants;
  import net.sourceforge.acelogger.constants.LocationGathererConstants;
  import net.sourceforge.acelogger.execution.LogController;
  import net.sourceforge.acelogger.level.LogLevel;
  import net.sourceforge.acelogger.level.filter.LevelFilter;
  import net.sourceforge.acelogger.location.gatherer.LocationGatherer;
  
  /**
   * Abstracts all common tasks for {@link Logger}.
   * 
   * @author Zardi (https://sourceforge.net/users/daniel_zardi)
   * @version 1.0.0
   * @since 1.0.0
   */
  public abstract class BaseLogger implements Logger {
  
  	/**
  	 * The level filter used within this logger.
  	 */
  	private LevelFilter threshold;
  
  	/**
  	 * The appender used within this logger.
  	 */
  	private Appender appender;
  
  	/**
  	 * The location gatherer used within this logger.
  	 */
  	private LocationGatherer gatherer;
  
  	/**
  	 * The identifier of this logger.
  	 */
  	private String identifier;
  
  	/**
  	 * Constructs a new BaseLogger using the supplied identifier, an empty appender, a "deny all"
  	 * level filter and an empty location gatherer.
  	 * 
  	 * @param identifier
  	 *            A string that identifies this logger.
  	 * @since 1.0.0
  	 */
  	protected BaseLogger(String identifier) {
  		this(identifier, AppenderConstants.EMPTY, LevelFilterConstants.ACCEPT_NONE,
  				LocationGathererConstants.EMPTY);
  	}
  
  	/**
  	 * Constructs a new BaseLogger using the supplied identifier, appender, level filter and
  	 * location gatherer.
  	 * 
  	 * @param identifier
  	 *            A string that identifies this logger.
  	 * @param appender
  	 *            The {@link Appender} that will be used within this logger.
  	 * @param filter
  	 *            The {@link LevelFilter} that will be used within this logger.
  	 * @param gatherer
  	 *            The {@link LocationGatherer} that will be used within this logger.
  	 * @since 1.0.0
  	 */
  	protected BaseLogger(String identifier, Appender appender, LevelFilter filter,
  			LocationGatherer gatherer) {
  		setIdentifier(identifier);
  		setAppender(appender);
  		setThreshold(filter);
  		setGatherer(gatherer);
  	}
  
  	/**
  	 * Returns the level filter used within this logger.
  	 * 
  	 * @return The {@link LevelFilter} used within this logger.
  	 * @since 1.0.0
  	 */
  	public final LevelFilter getThreshold() {
  		return threshold;
  	}
  
 	/**
 	 * Sets the level filter used within this logger.
 	 * 
 	 * @param filter
 	 *            The {@link LevelFilter} that will be used within this logger.
 	 * @since 1.0.0
 	 */
 	public final void setThreshold(LevelFilter filter) {
 		if (filter == null) {
 			LogController.getInternalLogger().error(
 					"Received an <null> value for filter in logger \"{0}\". As a"
 					+ " result this logger will accept no messages", getIdentifier()
 				);
 			threshold = LevelFilterConstants.ACCEPT_NONE;
 		} else {
 			threshold = filter;
 		}
 	}
 
 	/**
 	 * Returns the location gatherer used within this logger.
 	 * 
 	 * @return The {@link LocationGatherer} used within this logger.
 	 * @since 1.0.0
 	 */
 	public final LocationGatherer getGatherer() {
 		return gatherer;
 	}
 
 	/**
 	 * Sets the location gatherer used within this logger.
 	 * 
 	 * @param gatherer
 	 *            The {@link LocationGatherer} that will be used within this logger.
 	 * @since 1.0.0
 	 */
 	public final void setGatherer(LocationGatherer gatherer) {
 		if (gatherer == null) {
 			LogController.getInternalLogger().error(
 					"Received an <null> value for gatherer in logger \"{0}\". As a"
 					+ " result this logger will not generate call location information",
 					getIdentifier()
 				);
 			this.gatherer = LocationGathererConstants.EMPTY;
 		} else {
 			this.gatherer = gatherer;
 		}
 	}
 
 	/** {@inheritDoc} */
 	public final String getIdentifier() {
 		return identifier;
 	}
 
 	/**
 	 * Sets the string that identifies this object.
 	 * 
 	 * @param identifier
 	 *            The identifier of this object.
 	 * @since 1.0.0
 	 */
 	private final void setIdentifier(String identifier) {
 		this.identifier = identifier;
 	}
 
 	/**
 	 * Returns the log appender used within this logger.
 	 * 
 	 * @return The {@link Appender} used within this logger.
 	 * @since 1.0.0
 	 */
 	public final Appender getAppender() {
 		return appender;
 	}
 
 	/**
 	 * Sets the log appender used within this logger.
 	 * 
 	 * @param appender
 	 *            The {@link Appender} that will be used within this logger.
 	 * @since 1.0.0
 	 */
 	private final void setAppender(Appender appender) {
 		if (appender == null) {
 			LogController.getInternalLogger().error(
 					"Received an <null> value for appender in logger \"{0}\". As a"
 					+ " result this logger won't output any message", getIdentifier()
 				);
 			this.appender = AppenderConstants.EMPTY;
 		} else {
 			this.appender = appender;
 		}
 	}
 
 	/**
 	 * Generates a log call based on the supplied information.
 	 * 
 	 * @param message
 	 *            The message to be logged.
 	 * @param params
 	 *            The parameters that should be available for formatting.
 	 * @param level
 	 *            The level of the log call.
 	 * @return A {@link LogEvent} generated with the supplied information.
 	 * @since 1.0.0
 	 */
 	protected final LogEvent generateLogCall(String message, Object[] params, LogLevel level) {
 		return generateLogCall(message, params, level, null);
 	}
 
 	/**
 	 * Generates a log call based on the supplied information.
 	 * 
 	 * @param message
 	 *            The message to be logged.
 	 * @param params
 	 *            The parameters that should be available for formatting.
 	 * @param level
 	 *            The level of the log call.
 	 * @param cause
 	 *            The origin of the reported problem.
 	 * @return A {@link LogEvent} generated with the supplied information.
 	 * @since 1.0.0
 	 */
 	protected final LogEvent generateLogCall(String message, Object[] params, LogLevel level,
 			Throwable cause) {
 		return generateLogCall(message, params, level, cause, Thread.currentThread());
 	}
 
 	/**
 	 * Generates a log call based on the supplied information.
 	 * 
 	 * @param message
 	 *            The message to be logged.
 	 * @param params
 	 *            The parameters that should be available for formatting.
 	 * @param level
 	 *            The level of the log call.
 	 * @param cause
 	 *            The origin of the reported problem.
 	 * @param currenThread
 	 *            The Thread where the log call was originated.
 	 * @return A {@link LogEvent} generated with the supplied information.
 	 * @since 1.0.0
 	 */
 	protected final LogEvent generateLogCall(String message, Object[] params, LogLevel level,
 			Throwable cause, Thread currenThread) {
 		LogEvent call = new LogEvent(message, level, gatherer.getCallLocation(currenThread), cause,
 				params);
 		return call;
 	}
 
 	/**
 	 * Checks if a level is suitable for logging within this logger.
 	 * 
 	 * @param level
 	 *            The level to be checked for.
 	 * @return True if the level is suitable for logging; False otherwise.
 	 * @since 1.0.0
 	 */
 	private final boolean isSuitableForLogging(LogLevel level) {
 		return threshold.isSuitable(level);
 	}
 
 	/** {@inheritDoc} */
 	public final boolean isDebugEnabled() {
 		return isSuitableForLogging(LogLevel.DEBUG);
 	}
 
 	/** {@inheritDoc} */
 	public final boolean isErrorEnabled() {
 		return isSuitableForLogging(LogLevel.ERROR);
 	}
 
 	/** {@inheritDoc} */
 	public final boolean isFatalEnabled() {
 		return isSuitableForLogging(LogLevel.FATAL);
 	}
 
 	/** {@inheritDoc} */
 	public final boolean isInfoEnabled() {
 		return isSuitableForLogging(LogLevel.INFO);
 	}
 
 	/** {@inheritDoc} */
 	public final boolean isTraceEnabled() {
 		return isSuitableForLogging(LogLevel.TRACE);
 	}
 
 	/** {@inheritDoc} */
 	public final boolean isWarnEnabled() {
 		return isSuitableForLogging(LogLevel.WARN);
 	}
 
 	/** {@inheritDoc} */
 	public final void debug(String message, Object... params) {
 		debug(message, null, params);
 	}
 
 	/** {@inheritDoc} */
 	public final void debug(String message, Throwable cause, Object... params) {
 		if (isDebugEnabled()) {
 			LogEvent call = generateLogCall(message, params, LogLevel.DEBUG, cause);
 			appender.appendLog(call);
 		}
 	}
 
 	/** {@inheritDoc} */
 	public final void error(String message, Object... params) {
 		error(message, null, params);
 	}
 
 	/** {@inheritDoc} */
 	public final void error(String message, Throwable cause, Object... params) {
 		if (isErrorEnabled()) {
 			LogEvent call = generateLogCall(message, params, LogLevel.ERROR, cause);
 			appender.appendLog(call);
 		}
 	}
 
 	/** {@inheritDoc} */
 	public final void fatal(String message, Object... params) {
 		fatal(message, null, params);
 	}
 
 	/** {@inheritDoc} */
 	public final void fatal(String message, Throwable cause, Object... params) {
 		if (isFatalEnabled()) {
 			LogEvent call = generateLogCall(message, params, LogLevel.FATAL, cause);
 			appender.appendLog(call);
 		}
 	}
 
 	/** {@inheritDoc} */
 	public final void info(String message, Object... params) {
 		info(message, null, params);
 	}
 
 	/** {@inheritDoc} */
 	public final void info(String message, Throwable cause, Object... params) {
 		if (isInfoEnabled()) {
 			LogEvent call = generateLogCall(message, params, LogLevel.INFO, cause);
 			appender.appendLog(call);
 		}
 	}
 
 	/** {@inheritDoc} */
 	public final void trace(String message, Object... params) {
 		trace(message, null, params);
 	}
 
 	/** {@inheritDoc} */
 	public final void trace(String message, Throwable cause, Object... params) {
 		if (isTraceEnabled()) {
 			LogEvent call = generateLogCall(message, params, LogLevel.TRACE, cause);
 			appender.appendLog(call);
 		}
 	}
 
 	/** {@inheritDoc} */
 	public final void warn(String message, Object... params) {
 		warn(message, null, params);
 	}
 
 	/** {@inheritDoc} */
 	public final void warn(String message, Throwable cause, Object... params) {
 		if (isWarnEnabled()) {
 			LogEvent call = generateLogCall(message, params, LogLevel.WARN, cause);
 			appender.appendLog(call);
 		}
 	}
 
 }