/*
    * 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.execution;
  
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.text.MessageFormat;
  import java.util.MissingResourceException;
  import java.util.ResourceBundle;
  
  import net.sourceforge.acelogger.LogEvent;
  import net.sourceforge.acelogger.Logger;
  import net.sourceforge.acelogger.constants.FormatterConstants;
  import net.sourceforge.acelogger.formatter.Formatter;
  import net.sourceforge.acelogger.level.LogLevel;
  import net.sourceforge.acelogger.location.LogEventLocation;
  import net.sourceforge.acelogger.location.gatherer.LocationGatherer;
  
  // FIXME: This is such a mess, let's just re-think this.
  /**
   * An implementation of {@link Logger} to be used during the startup and shutdown of the framework.
   * If other classes are used here, they shouldn't use the internal logger to report errors, so it's
   * safer to use simple variations of these classes.
   * 
   * @author Zardi (https://sourceforge.net/users/daniel_zardi)
   * @version 1.0.0
   * @since 1.0.0
   */
  public class InternalLogger implements Logger {
  
  	private static final String IDENTIFIER = "net.sourceforge.acelogger";
  
  	private Formatter formatter;
  
  	private LocationGatherer gatherer;
  
  	private static class InternalFormatter implements Formatter {
  
  		private static final String RESOURCE_BUNDLE_NAME =
  			"net.sourceforge.acelogger.messages.InternalLogging";
  
  		private static final String LOG_ENTRY_PATTERN =
  			"{0,date,yyyy-MM-dd HH:mm:ss,SSS} [{1}] ({2}) - {3}" + FormatterConstants.NEW_LINE;
  
  		private ResourceBundle resolver;
  
  		public InternalFormatter() {
  			resolver = ResourceBundle.getBundle(RESOURCE_BUNDLE_NAME);
  		}
  
  		/** {@inheritDoc} */
  		public String formatLogCall(LogEvent call) {
  			String resolvedPattern = "";
  			try {
  				// FIXME: It hangs Here.. WTF !!!!!!! Can't we use a stream??
  				resolvedPattern = resolver.getString(call.getMessage());
  			} catch (NullPointerException e) {
  				// FIXME: An error inside another one, this is so confusing. What should we do?
  			} catch (MissingResourceException e) {
  				// FIXME: An error inside another one, this is so confusing. What should we do?
  			} catch (ClassCastException e) {
  				// FIXME: An error inside another one, this is so confusing. What should we do?
  			} catch (Throwable e) {
  				e.printStackTrace();
  			}
  			String formattedMessage = MessageFormat.format(
  					resolvedPattern, call.getMessageParameters()
  				);
  			StringBuilder formattedLogCall = new StringBuilder();
  			formattedLogCall.append(MessageFormat.format(LOG_ENTRY_PATTERN, call.getCallTime(),
  					call.getLevel(), call.getLocation().getStackTraceLikeName(), formattedMessage
  				));
  			if (call.getCause() != null) {
  				StringWriter stackTraceDestination = new StringWriter();
  				PrintWriter stackTraceWriter = new PrintWriter(stackTraceDestination);
  				call.getCause().printStackTrace(stackTraceWriter);
  				stackTraceWriter.flush();
  				stackTraceWriter.close();
  				formattedLogCall.append(stackTraceDestination.toString());
  			}
  			return formattedLogCall.toString();
  		}
  
  		/** {@inheritDoc} */
  		public String getIdentifier() {
  			return IDENTIFIER;
  		}
 
 	}
 
 	private static class InternalLocationGatherer implements LocationGatherer {
 
 		private static final int FRAME_SHIFT = 3;
 
 		/** {@inheritDoc} */
 		public LogEventLocation getCallLocation() {
 			return getCallLocation(Thread.currentThread());
 		}
 
 		/** {@inheritDoc} */
 		public LogEventLocation getCallLocation(Thread currentThread) {
 			StackTraceElement[] stackTrace = currentThread.getStackTrace();
 			int userCodeCallIndex = 0;
 			for (int i = 0; i < stackTrace.length; i++) {
 				String frameClassName = stackTrace[i].getClassName();
 				if (!frameClassName.startsWith("java.util.concurrent")
 						&& !frameClassName.startsWith("java.lang.Thread")
 						&& !frameClassName.startsWith(InternalLogger.class.getName())
 						&& !frameClassName.startsWith(UncaughtExceptionLogger.class.getName())) {
 					userCodeCallIndex = i;
 					if (i + FRAME_SHIFT < stackTrace.length) {
 						userCodeCallIndex += FRAME_SHIFT;
 					}
 					break;
 				}
 			}
 			StackTraceElement userCodeFrame = stackTrace[userCodeCallIndex];
 			return new LogEventLocation(
 					userCodeFrame.getClass().getPackage().getName(),
 					userCodeFrame.getClassName(),
 					userCodeFrame.getMethodName(),
 					userCodeFrame.getFileName(),
 					userCodeFrame.getLineNumber(),
 					currentThread.getName()
 				);
 		}
 
 		/** {@inheritDoc} */
 		public String getIdentifier() {
 			return IDENTIFIER;
 		}
 
 	}
 
 	/**
 	 * Constructs a new internal logger.
 	 * 
 	 * @since 1.0.0
 	 */
 	public InternalLogger() {
 		formatter = new InternalFormatter();
 		gatherer = new InternalLocationGatherer();
 	}
 
 	/** {@inheritDoc} */
 	public void debug(String message, Object... params) {
 		// REMARK: Intentionally left blank. This Logger does not support debug.
 	}
 
 	/** {@inheritDoc} */
 	public void debug(String message, Throwable cause, Object... params) {
 		// REMARK: Intentionally left blank. This Logger does not support debug.
 	}
 
 	/** {@inheritDoc} */
 	public void error(String message, Object... params) {
 		LogEvent call = new LogEvent(
 				message, LogLevel.ERROR, gatherer.getCallLocation(), null, params);
 		System.out.print(formatter.formatLogCall(call));
 	}
 
 	/** {@inheritDoc} */
 	public void error(String message, Throwable cause, Object... params) {
 		LogEvent call = new LogEvent(
 				message, LogLevel.ERROR, gatherer.getCallLocation(), cause, params);
 		System.out.print(formatter.formatLogCall(call));
 	}
 
 	/** {@inheritDoc} */
 	public void fatal(String message, Object... params) {
 		LogEvent call = new LogEvent(
 				message, LogLevel.FATAL, gatherer.getCallLocation(), null, params);
 		System.out.print(formatter.formatLogCall(call));
 	}
 
 	/** {@inheritDoc} */
 	public void fatal(String message, Throwable cause, Object... params) {
 		LogEvent call = new LogEvent(
 				message, LogLevel.FATAL, gatherer.getCallLocation(), cause, params);
 		System.out.print(formatter.formatLogCall(call));
 	}
 
 	/** {@inheritDoc} */
 	public void info(String message, Object... params) {
 		LogEvent call = new LogEvent(
 				message, LogLevel.INFO, gatherer.getCallLocation(), null, params);
 		System.out.print(formatter.formatLogCall(call));
 	}
 
 	/** {@inheritDoc} */
 	public void info(String message, Throwable cause, Object... params) {
 		LogEvent call = new LogEvent(
 				message, LogLevel.INFO, gatherer.getCallLocation(), cause, params);
 		System.out.print(formatter.formatLogCall(call));
 	}
 
 	/** {@inheritDoc} */
 	public boolean isDebugEnabled() {
 		return false;
 	}
 
 	/** {@inheritDoc} */
 	public boolean isErrorEnabled() {
 		return true;
 	}
 
 	/** {@inheritDoc} */
 	public boolean isFatalEnabled() {
 		return true;
 	}
 
 	/** {@inheritDoc} */
 	public boolean isInfoEnabled() {
 		return true;
 	}
 
 	/** {@inheritDoc} */
 	public boolean isTraceEnabled() {
 		return false;
 	}
 
 	/** {@inheritDoc} */
 	public boolean isWarnEnabled() {
 		return true;
 	}
 
 	/** {@inheritDoc} */
 	public void trace(String message, Object... params) {
 		// REMARK: Intentionally left blank. This Logger does not support trace.
 	}
 
 	/** {@inheritDoc} */
 	public void trace(String message, Throwable cause, Object... params) {
 		// REMARK: Intentionally left blank. This Logger does not support trace.
 	}
 
 	/** {@inheritDoc} */
 	public void warn(String message, Object... params) {
 		// TODO Auto-generated method stub
 
 	}
 
 	/** {@inheritDoc} */
 	public void warn(String message, Throwable cause, Object... params) {
 		// TODO Auto-generated method stub
 
 	}
 
 	/** {@inheritDoc} */
 	public String getIdentifier() {
 		return IDENTIFIER;
 	}
 
 }