/*
      Licensed 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.
  */
  package uk.nhs.interoperability.util;
  
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  
  /**
   * Simple Logging class - created to avoid unnecessary dependencies
   * on external libraries.
   *
   * @author Michael Odling-Smee
   * @author Nicholas Jones
   * @since 0.1
   */
  public class Logger { 
  	
  	/** The Constant DATE_FORMAT. */
  	private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
  	
  	/** The Constant TRACE. */
  	public static final int TRACE = 0;
  	
  	/** The Constant DEBUG. */
  	public static final int DEBUG = 10;
  	
  	/** The Constant INFO. */
  	public static final int INFO = 20;
  	
  	/** The Constant WARN. */
  	public static final int WARN = 30;
  	
  	/** The Constant ERROR. */
  	public static final int ERROR = 40;
  	
  	/** The Constant FATAL. */
  	public static final int FATAL = 50;
  	
  	/** The log level. */
  	private static int logLevel = INFO;
  	
  	static {
  		logLevel = parseLogLevel(ITKApplicationProperties.getProperty("uk.nhs.interoperability.util.Logger.logLevel"));
  	}
  	
  	
  	/**
  	 * Log.
  	 *
  	 * @param level the level
  	 * @param message the message
  	 * @param t the t
  	 */
  	private static final void log(int level, String message, Throwable t) {
  		if (level >= logLevel) {
  			Calendar CAL = Calendar.getInstance();
  			String dateTime = DATE_FORMAT.format(CAL.getTime());
  			String threadId = Thread.currentThread().getName();
  			String logMessage = dateTime + " [" + threadId + "] " + " [" + logLevelStr(level) + "] " + getCallerInfo() + message;
  			if (t == null) {
  				System.out.println(logMessage);
  			} else {
  				System.out.println(logMessage + ", " + t.getLocalizedMessage());
  				t.printStackTrace(System.out);
  			}
  		}
  	}
  	
  	/**
  	 * Parses the log level.
  	 *
  	 * @param logLevelStr the log level str
  	 * @return the int
  	 */
  	private static final int parseLogLevel(String logLevelStr) {
  		if (logLevelStr != null) {
  			if (logLevelStr.equalsIgnoreCase("TRACE")) {
  				return TRACE;
  			} else if (logLevelStr.equalsIgnoreCase("DEBUG")) {
  				return DEBUG;
  			}  else if (logLevelStr.equalsIgnoreCase("INFO")) {
  				return INFO;
  			}  else if (logLevelStr.equalsIgnoreCase("WARN")) {
  				return WARN;
  			}  else if (logLevelStr.equalsIgnoreCase("ERROR")) {
  				return ERROR;
  			}  else if (logLevelStr.equalsIgnoreCase("FATAL")) {
  				return FATAL;
 			}
 		}
 		//Default to INFO level
 		return INFO;
 	}
 	
 	/**
 	 * Log level str.
 	 *
 	 * @param level the level
 	 * @return the string
 	 */
 	private static final String logLevelStr(int level) {
 		switch (level) {
 			case TRACE:
 				return "TRACE";
 			case DEBUG:
 				return "DEBUG";
 			case INFO:
 				return "INFO";
 			case WARN:
 				return "WARN";
 			case ERROR:
 				return "ERROR";
 			case FATAL:
 				return "FATAL";
 			default:
 				return null;
 		}
 	}
 	
 	/**
 	 * Trace.
 	 *
 	 * @param message the message
 	 */
 	public static final void trace(String message) {
 		log(TRACE, message, null);
 	}
 	
 	/**
 	 * Debug.
 	 *
 	 * @param message the message
 	 */
 	public static final void debug(String message) {
 		log(DEBUG, message, null);
 	}
 	
 	/**
 	 * Info.
 	 *
 	 * @param message the message
 	 */
 	public static final void info(String message) {
 		log(INFO, message, null);
 	}
 	
 	/**
 	 * Warn.
 	 *
 	 * @param message the message
 	 */
 	public static final void warn(String message) {
 		log(WARN, message, null);
 	}
 	
 	/**
 	 * Warn.
 	 *
 	 * @param message the message
 	 * @param t the t
 	 */
 	public static final void warn(String message, Throwable t) {
 		log(WARN, message, t);
 	}
 	
 	/**
 	 * Error.
 	 *
 	 * @param message the message
 	 * @param t the t
 	 */
 	public static final void error(String message, Throwable t) {
 		log(ERROR, message, t);
 	}
 	
 	/**
 	 * Fatal.
 	 *
 	 * @param message the message
 	 * @param t the t
 	 */
 	public static final void fatal(String message, Throwable t) {
 		log(FATAL, message, t);
 	}
 	
 	/**
 	 * Gets the caller info.
 	 *
 	 * @return the caller info
 	 */
 	private static String getCallerInfo() {
 		return getClassAndMethod(Thread.currentThread().getStackTrace()[4]);
 	}
 	
 	/**
 	 * Gets the class and method.
 	 *
 	 * @param ste the ste
 	 * @return the class and method
 	 */
 	private static String getClassAndMethod(StackTraceElement ste) {
 		String className = ste.getClassName().substring(ste.getClassName().lastIndexOf(".") + 1);
 		return className + "." + ste.getMethodName() + "(l:" + ste.getLineNumber() + ") ";
 	}
 
 }