/*

  * 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;

         }

 }