/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight 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 General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.mindtree.techworks.insight.preferences.util;
  
  import java.util.HashMap;
  import java.util.StringTokenizer;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.gui.widgets.StatusBar;
  import com.mindtree.techworks.insight.model.ReceiverFormat;
  import com.mindtree.techworks.insight.preferences.PreferenceManager;
  import com.mindtree.techworks.insight.preferences.model.Preference;
  import com.mindtree.techworks.insight.preferences.model.PreferenceAttribute;
  
  /**
   * The <code>Log4JPatternInterpeter</code> class interprets the pattern layout
   * of Log4J and returns a pattern format that is recognized by the Log pattern
   * receiver.
   * <p>
   * The following variables used in PatternLayout and the interpretation are:
   * <ul>
   * <li>%c - category LOGGER</li>
   * <li>%C - Class name CLASS</li>
   * <li>%d - date TIMESTAMP</li>
   * <li>%l - location information FILE</li>
   * <li>%F - location information FILE</li>
   * <li>%L - Line number of caller LINE</li>
   * <li>%m - application message MESSAGE</li>
   * <li>%M - method name of caller METHOD</li>
   * <li>%p - priority LEVEL</li>
   * <li>%r - number of milliseconds elapsed time since start RELATIVETIME</li>
   * <li>%t - thread name THREAD</li>
   * <li>%x - NDC (nested diagnostic context) associated with the thread NDC
   * <li>%n - Line feed
   * </li>
   * </ul>
   * </p>
   * 
   * @author Regunath B
   * @version 1.0, 04/12/30
   * @see com.mindtree.techworks.insight.model.ReceiverFormat
   */
  public class Log4JPatternInterpeter {
  
  	/**
  	 * Id of the Preference
  	 */
  	private static final String PREFERENCE_ID = "log4jPattern";
  
  	/**
  	 * A string array for valid logging patterns.
  	 */
  	private static final String[] LOGGING_PATTERNS = {"primaryPattern","secondaryPattern"};
  	
  	/**
  	 * Useful map of the Log4JPattern and the respective interpreted canonical
  	 * keywords recognized by the receiver
  	 */
  	private static HashMap PATTERN_MATCH = new HashMap();
  	static {
  		PATTERN_MATCH.put("c", "LOGGER");
  		PATTERN_MATCH.put("C", "CLASS");
  		PATTERN_MATCH.put("d", "TIMESTAMP");
  		PATTERN_MATCH.put("l", "FILE");
  		PATTERN_MATCH.put("F", "FILE");
  		PATTERN_MATCH.put("L", "LINE");
  		PATTERN_MATCH.put("m", "MESSAGE");
  		PATTERN_MATCH.put("M", "METHOD");
  		PATTERN_MATCH.put("p", "LEVEL");
  		PATTERN_MATCH.put("r", "RELATIVETIME");
  		PATTERN_MATCH.put("t", "THREAD");
  		PATTERN_MATCH.put("x", "NDC");
  		// set of chars that are replaced with ""
  		PATTERN_MATCH.put("n", "");
  	}
  
  	/**
 	 * Array of recognized patterns/characters
 	 */
 	private static final String [] RECOGNIZED_PATTERNS = { 
 			"c", // 0
 			"C", //1
 			"d", //2
 			"l", //3
 			"F", //4
 			"L", //5
 			"m", //6
 			"M", //7
 			"p", //8
 			"r", //9
 			"t", //10
 			"x", //11
 			"n", //12
 	};
 
 	/**
 	 * Useful constant for specific indices in the above list of recognized
 	 * patterns
 	 */
 	private static final int TIMESTAMP_INDEX = 2;
 
 	/**
 	 * Useful Constant for characters
 	 */
 	private static final String PERCENT = "%";
 
 	/**
 	 * Useful Constant for characters
 	 */
 	private static final char BRACKET_START = '{';
 
 	/**
 	 * Useful Constant for characters
 	 */
 	private static final char BRACKET_END = '}';
 
 
 	/**
 	 * Gets the interpreted receiver-recognizable pattern for the specified
 	 * Log4j pattern
 	 * 
 	 * @param log4jPattern the Log4j pattern to be interpreted
 	 * @return the receiver recognizable ReceiverFormat
 	 * @deprecated Use the
 	 *             {@link Log4JPatternInterpeter#getInterpretedRecieverFormat() getInterpretedRecieverFormat()}
 	 *             method instead.
 	 */
 	public static ReceiverFormat getInterpretedFormat (String log4jPattern) {
 
 		StringBuffer interpretedPattern = new StringBuffer();
 		String timeFormat = null;
 		StringTokenizer tokenizer = new StringTokenizer(log4jPattern, PERCENT);
 		try {
 			while (tokenizer.hasMoreTokens()) {
 				String token = tokenizer.nextToken();
 				for (int i = 0; i < RECOGNIZED_PATTERNS.length; i++ ) {
 					int keyCharIndex = token.indexOf(RECOGNIZED_PATTERNS[i]);
 					if (keyCharIndex > -1) { // there is a recognized keyword
 						token = PATTERN_MATCH.get(RECOGNIZED_PATTERNS[i])
 								+ token.substring(keyCharIndex + 1, token
 										.length());
 						int bracketIndex = token.indexOf(BRACKET_START);
 						if (bracketIndex > -1) {
 							if (i == TIMESTAMP_INDEX) { // Timestamp format
 								// exists
 								timeFormat = token.substring(bracketIndex + 1,
 										token.indexOf(BRACKET_END));
 							}
 							token = token.substring(0, bracketIndex)
 									+ token.substring(token
 											.indexOf(BRACKET_END) + 1, token
 											.length());
 						}
 						break;
 					}
 				}
 				interpretedPattern.append(token);
 			}
 		} catch (Exception e) { // Catch all possible exceptions due to bad
 			// pattern
 			e.printStackTrace();
 			StatusBar.getInstance().setDisplayText(0,
 					InsightConstants.getLiteral("ERROR_LOG4J_PATTERN"), false);
 			return new ReceiverFormat("", "", "");
 		}
 		return new ReceiverFormat(log4jPattern, interpretedPattern.toString()
 				.trim(), timeFormat);
 	}
 
 	/**
 	 * Gets the interpreted Receiver Format from the Preferences
 	 * 
 	 * @return RecieverFormat from the Preferences
 	 */
 	public static ReceiverFormat[] getInterpretedRecieverFormat () {
 
 		Preference preference = PreferenceManager.getInstance().getPreference(
 				PREFERENCE_ID);
 		ReceiverFormat[] receiverFormat = new ReceiverFormat[LOGGING_PATTERNS.length];
 		/*
 		 *Trying to add support for multiple patterns by making receiver format an array.
 		 */
 		for(int i=0; i<LOGGING_PATTERNS.length; i++){
 			PreferenceAttribute preferenceAttribute = preference.getPreferenceAttributeById(LOGGING_PATTERNS[i]);
 			receiverFormat[i] = getInterpretedFormat(preferenceAttribute.getValue());
 		}
 		return receiverFormat;
 	}
 
 	/**
 	 * Entry method to test this interpreter
 	 * 
 	 * @param args
 	 */
 	public static void main (String [] args) {
 
 		//System.out.println(Log4JPatternInterpeter.getInterpretedFormat("%d{dd
 		// MMM yyyy HH:mm:ss,SSS} %t %-5p %c{2} - %m%n"));
 		//System.out.println(Log4JPatternInterpeter.getInterpretedFormat("%d
 		// %-5p %c --> %M() [%t]: %m %n"));
 		//System.out.println(Log4JPatternInterpeter.getInterpretedFormat("%d{HH:mm:ss,SSS}
 		// [%-9t] %-5p [%-42c{3}] %x - %m%n"));
 		System.out.println(Log4JPatternInterpeter
 				.getInterpretedFormat("####<%d{MMM dd, yyyy hh:mm:ss a z}> %m%n"));
 		//System.out.println(Log4JPatternInterpeter.getInterpretedRecieverFormat());
 	}
 
 }