/*
    * $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.appender;
  
  import java.util.StringTokenizer;
  import java.util.regex.Pattern;
  
  import org.apache.log4j.Appender;
  import org.apache.log4j.Layout;
  import org.apache.log4j.helpers.OnlyOnceErrorHandler;
  import org.apache.log4j.spi.ErrorHandler;
  import org.apache.log4j.spi.Filter;
  import org.apache.log4j.spi.LoggerRepository;
  import org.apache.log4j.spi.LoggingEvent;
  
  import com.mindtree.techworks.insight.Controller;
  import com.mindtree.techworks.insight.model.LogEventModel;
  import com.mindtree.techworks.insight.pagination.IPage;
  import com.mindtree.techworks.insight.pagination.PageSet;
  import com.mindtree.techworks.insight.receiver.RuntimeNamespaceContainer;
  import com.mindtree.techworks.insight.spi.LogEvent;
  import com.mindtree.techworks.insight.spi.LogLevel;
  
  /**
  *
  * The <code>ParsedEventAppender</code> class implements the Apache Appender interface.
  * This implementation caches the received parsed LoggingEvent instance and passes it
  * on to the Controller instance that this Appender was instantiated with.
  * Many methods in this class donot have an implementation. May be added if need be. 
  *
  * @author  Regunath B
  * @version 1.0, 04/10/25
  * @see     org.apache.log4j.Appender
  */
  
  public class ParsedEventAppender extends LogEventModel implements Appender {
  	
  	/**
  	 * Used for object serialization
  	 */
  	private static final long serialVersionUID = 217646441758807591L;
  
  	/*
  	 * Useful constant for the LogEvent sequence start number
  	 */
  	private static final long LOG_EVENT_SEQUENCE_START = 1L;
  
      /*
       * Useful constants to identify the Exception string in stack traces
       */
      public static final String EXCEPTION_STRING = "EXCEPTION";
      private static final int EXCEPTION_STRING_LENGTH = EXCEPTION_STRING.length();
  	
  	/*
  	 * Useful regex for permissible chars in Exception class name
  	 */
      private static final Pattern CLASS_NAME_PATTERN = Pattern.compile("[a-zA-Z0-9.]");
  	
  	/*
  	 * Default name for this Appender
  	 */
  	private static final String NAME = "Parsed Event Appender";
  	
  	/*
  	 * Singleton instance of this Appender
  	 */
  	private static ParsedEventAppender instance;
  
  	/*
  	 * The ErrorHandler instance that all Appender implementations need to support
  	 */
  	private ErrorHandler errorHandler;
  
  	/*
  	 * Filter for data handled by this Appender
  	 */
  	private Filter filter;
 
 	/*
 	 * Layout for this Appender
 	 */
 	private Layout layout;
 
 	/*
 	 * Stores the name of this Appender
 	 */
 	private String name = NAME;
 	
 	/*
 	 * Variable that holds the next sequence number for LogEvent instances
 	 */
 	private long nextLogEventSequenceNumber = LOG_EVENT_SEQUENCE_START;
 
 	/**
 	 * LogEventModel Name
 	 */
 	private static final String LOG_EVENT_MODEL_NAME = "R";
 	
 	/**
 	 * Private Constructor for this class to prevent multiple instances
 	 * @param controller the Controller instance that gets notified when this Appender receives events
 	 * @see #getInstance(Controller)
 	 */
 	private ParsedEventAppender(Controller controller) {
 		super(controller);
 		this.errorHandler = new OnlyOnceErrorHandler();
 		this.controller.setRootLogEventModel(this);
 		setLogEventModelName(LOG_EVENT_MODEL_NAME);
 	}
 	
 	/**
 	 * Accessor method to get the singleton instance of this class.
 	 * @param controller the Controller that will be notified of parsed events. 
 	 * @return the sungleton instance of this class
 	 */
 	public static final synchronized ParsedEventAppender getInstance(Controller controller) {
 		if (instance == null) {
 			instance = new ParsedEventAppender(controller);
 		}
 		return instance;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation.
 	 * @param newFilter the Filter instance to add
 	 * 
 	 */
 	public void addFilter(Filter newFilter) {
 		this.filter = newFilter;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation.
 	 * @return null or the Filter instance for this Appender
 	 * 
 	 */
 	public Filter getFilter() {
 		return this.filter;
 	}
 
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation.
 	 * Sets the Filter reference of this class to null 
 	 */
 	public void clearFilters() {
 		this.filter = null;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation.
 	 */
 	public void close() {
 		// un-register listeners if any.
 	}
 
 	/**
 	 * Appender interface implementation. 
 	 * @param loggingEvent the LoggingEvent instance that has been received
 	 */
 	public void doAppend(LoggingEvent loggingEvent) {
 		appendEvent(loggingEvent instanceof LogEvent ? (LogEvent)loggingEvent : new LogEvent(loggingEvent));
 	}
 	
 	/**
 	 * Appends the specified LogEvent.
 	 * @param event the LogEvent instance that has been received
 	 */
 	public synchronized void appendEvent(LogEvent event) {
 		event.setSequenceNumber(this.nextLogEventSequenceNumber);
 		this.nextLogEventSequenceNumber += 1;
 		event.setExceptionName(getExceptionClassName(event));
 		IPage page = pageSet.getLastPage();
 		page.addLogEvent(event);
 		super.fireLogEventAdded(event);
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. Returns the name of this Appender
 	 * @return the name of this Appender
 	 * 
 	 */
 	public String getName() {
 		return this.name;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. Sets the specified ErrorHandler
 	 * for this Appender
 	 * @param handler the ErrorHandler for this Appender
 	 * 
 	 */
 	public void setErrorHandler(ErrorHandler handler) {
 		this.errorHandler = handler;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. Returns the ErrorHandler of this Appender
 	 * @return the ErrorHandler for this Appender
 	 * 
 	 */
 	public ErrorHandler getErrorHandler() {
 		return this.errorHandler;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. 
 	 * @param layout the Layout for this Appender
 	 * 
 	 */
 	public void setLayout(Layout layout) {
 		this.layout = layout;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. Returns the Layout of this Appender
 	 * 
 	 */
 	public Layout getLayout() {
 		return this.layout;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. Sets the name of this Appender
 	 * @param name the name of this Appender
 	 * 
 	 */
 	public void setName(String name) {
 		this.name = name;
 	}
 
 	/**
 	 * Appender interface implementation.
 	 * Contains no significant implementation. Returns false
 	 */
 	public boolean requiresLayout() {
 		return false;
 	}
 	
 	/**
 	 * Helper method that return the Exception name if the LogEvent
 	 * is of ERROR or FATAL or WARN priority
      * @param event the LogEvent that potentially contains an Exception class name
      * @return empty string or the Exception class name, if found
 	 */
     private final String getExceptionClassName(LogEvent event) {
     	String exceptionName = "";
 		int levelInt = event.getLevel().toInt();
 		if ((levelInt == LogLevel.ERROR_INT) || (levelInt == LogLevel.FATAL_INT) || (levelInt == LogLevel.WARN_INT)) {
 			// try to get exception name from stack trace
 			String[] throwableInfo = event.getThrowableStrRep();
 			for (int i = 0; i < throwableInfo.length; i++) {
 				if (throwableInfo[i].toUpperCase().indexOf(EXCEPTION_STRING) > -1) {
 					exceptionName = getExceptionNameFromString(throwableInfo[i]);
 					break;
 				}
 			}
 			if (exceptionName.length() == 0) {
 				// try to get Exception name from message string
 				exceptionName =  getExceptionNameFromString(event.getMessage().toString());
 			}
 		}
 		return exceptionName;
     }
     
     /**
      * Helper method that gets the Exception class name from the specified string
      * @param line the input line that potentially contains the Exception class name
      * @return empty string or the Exception class name, if found
      */
     private final String getExceptionNameFromString(String line) {
     	String exceptionClassName = "";
     	StringTokenizer tokenizer = new StringTokenizer(line);
     	while(tokenizer.hasMoreTokens()) {
     		String token = tokenizer.nextToken();
     		int exceptionIndex = token.toUpperCase().lastIndexOf(EXCEPTION_STRING);
     		if (exceptionIndex > -1) {
     			int startIndex = exceptionIndex;
     			int prevIndex = startIndex - 1;
     			while(prevIndex >= 0) {
     				char[] prevChar = new char[] {token.charAt(prevIndex)};
     				if (CLASS_NAME_PATTERN.matcher(new String(prevChar)).matches()) { // proceed only for class/package name chars permitted by Java
         				startIndex = prevIndex;
         				prevIndex -= 1;
     				} else {
     					break;
     				}
     			}
     			exceptionClassName = token.substring(startIndex,exceptionIndex + EXCEPTION_STRING_LENGTH);
     			break;
     		}
     	}
     	return exceptionClassName;
     }
     
     /**
      * Clears the loaded namespaces
      *  
      * @see com.mindtree.techworks.insight.model.LogEventModel#clear()
      */
     public void clear(){
     	super.clear();
     	// Initialize the page set because the root model always needs an active pageset
     	this.initializePageSet();
     	this.nextLogEventSequenceNumber = LOG_EVENT_SEQUENCE_START;
     	RuntimeNamespaceContainer.clearLoadedNamespaces();
     }
     
     /*
      * Helper method to initialize the page set for this LogEventModel
      */
     private void initializePageSet() {
 		if(null == pageSet){
 			pageSet = new PageSet();
 			setPageSet(pageSet);
 		}
     }
 
 	public void setLoggerRepository(LoggerRepository arg0) {
 		// TODO Auto-generated method stub
 		
 	}
 }