/*
    * $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.eventsearch;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import java.util.regex.PatternSyntaxException;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.gui.EventDetailsPresentation;
  import com.mindtree.techworks.insight.gui.Insight;
  import com.mindtree.techworks.insight.gui.widgets.StatusBar;
  import com.mindtree.techworks.insight.model.ILogEventModelMutator;
  import com.mindtree.techworks.insight.model.IMutatorListener;
  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.spi.LogEvent;
  
  
  /**
   * Provides the Event Search functionality to Insight, based on the search
   * criteria selected by the user.
   * 
   * @see com.mindtree.techworks.insight.gui.action.SearchAction SearchAction
   * @see com.mindtree.techworks.insight.gui.search.SearchEventsFrame SearchEventsFrame
   * @author Bindul Bhowmik
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  public class EventSearchProvider extends Thread implements
  		ILogEventModelMutator {
  
  	//
  	// Instance variables
  	//
  
  	/**
  	 * Whether to indicate the progress of the search in the status bar.
  	 */
  	private boolean indicateProgress = true;
  
  	/**
  	 * Holds a reference to the current instance of <code>Insight</code>
  	 */
  	private Insight insightInstance;
  
  	/**
  	 * The EventDetailsPresentation whose contents will be searched
  	 */
  	private EventDetailsPresentation eventDetailsPresentation;
  
  	/**
  	 * The instance of status bar to notify to
  	 */
  	private StatusBar statusBar;
  
  	/**
  	 * Flag to indicate whether to stop the search
  	 */
  	private boolean stopSearch = false;
  
  	/**
  	 * Counts the number of matches
  	 */
  	private long matchCount = 0;
  
  	/**
  	 * Holds a reference to the current search criteria.
  	 */
  	private SearchCriteria searchCriteria;
  
  	/**
  	 * Stores the current search pattern
  	 */
 	private Pattern searchPattern;
 
 	/**
 	 * Stores the matcher for the search string.
 	 */
 	private Matcher searchMatcher;
 
 	/**
 	 * Listeners of this mutating operation
 	 */
 	private List mutatorListeners = new ArrayList();
 
 	//
 	// Search Criteria type indicators
 	//
 	/**
 	 * Indicates to search in the thread field
 	 */
 	private boolean searchThread = false;
 
 	/**
 	 * Indicates to search in the category field
 	 */
 	private boolean searchCategory = false;
 
 	/**
 	 * Indicates to search in the message field
 	 */
 	private boolean searchMessage = false;
 
 	/**
 	 * Indicates to search in the exception class name field
 	 */
 	private boolean searchExceptionClassName = false;
 
 	/**
 	 * Indicates to search in the throwable stack trace
 	 */
 	private boolean searchThrowable = false;
 
 	/**
 	 * Indicates to search in priority field
 	 */
 	private boolean searchPriority = false;
 
 	/**
 	 * Indicates to search in the namespace string representation
 	 */
 	private boolean searchNamespace = false;
 
 	//
 	// Constructor
 	//
 
 	/**
 	 * Constructor for the class.
 	 * 
 	 * @param insightInstance The current instance of <code>Insight</code>.
 	 * @param indicateProgress Whether to indicate the progress of the search in
 	 *            the status bar.
 	 * @param eventDetailsPresentation The event details presentation used for
 	 *            highlighting
 	 */
 	public EventSearchProvider (Insight insightInstance,
 			boolean indicateProgress,
 			EventDetailsPresentation eventDetailsPresentation) {
 
 		this.insightInstance = insightInstance;
 		this.eventDetailsPresentation = eventDetailsPresentation;
 		this.indicateProgress = indicateProgress;
 		statusBar = StatusBar.getInstance();
 		this.addMutatorListener(insightInstance.getController());
 		
 	  	// explicitly set the priority to normal. Otherwise
 	  	// this thread will inherit the priority of the creator thread
 	  	// i.e the AWT event dispatch thread that runs with max priority
 		this.setPriority(Thread.NORM_PRIORITY);		
 	}
 
 	//
 	// Public Methods
 	//
 
 	/**
 	 * Searches the passed pageSet for the search criteria
 	 * 
 	 * @param currentSearchCriteria The {@link SearchCriteria SearchCriteria}
 	 *            object containing the data to search.
 	 */
 	public void searchLogEvents (SearchCriteria currentSearchCriteria) {
 
 		// Set the search criteria
 		this.searchCriteria = currentSearchCriteria;
 		try {
 			searchPattern = Pattern.compile(searchCriteria.getSearchString(),
 					Pattern.CASE_INSENSITIVE | Pattern.DOTALL
 							| Pattern.MULTILINE | Pattern.CANON_EQ
 							| Pattern.UNICODE_CASE);
 		} catch (PatternSyntaxException e) {
 			statusBar.setDisplayText(0, InsightConstants
 					.getLiteral("ERROR_INVALID_REGEX_PATTERN"), false);
 			return;
 		}
 
 		// Set the type of search
 		int type = searchCriteria.getSearchType();
 		if ((type & SearchCriteria.MESSAGE_SEARCH) == SearchCriteria.MESSAGE_SEARCH) {
 			searchMessage = true;
 		}
 
 		if ((type & SearchCriteria.CATEGORY_SEARCH) == SearchCriteria.CATEGORY_SEARCH) {
 			searchCategory = true;
 		}
 
 		if ((type & SearchCriteria.EXCEPTION_CLASS_NAME_SEARCH) == SearchCriteria.EXCEPTION_CLASS_NAME_SEARCH) {
 			searchExceptionClassName = true;
 		}
 
 		if ((type & SearchCriteria.THREAD_SEARCH) == SearchCriteria.THREAD_SEARCH) {
 			searchThread = true;
 		}
 
 		if ((type & SearchCriteria.THROWABLE_SEARCH) == SearchCriteria.THROWABLE_SEARCH) {
 			searchThrowable = true;
 		}
 
 		if ((type & SearchCriteria.PRIORITY_SEARCH) == SearchCriteria.PRIORITY_SEARCH) {
 			searchPriority = true;
 		}
 
 		if ((type & SearchCriteria.NAMESPACE_SEARCH) == SearchCriteria.NAMESPACE_SEARCH) {
 			searchNamespace = true;
 		}
 
 		this.start();
 	}
 
 	//
 	// Methods from Runnable
 	//
 
 	/**
 	 * @see java.lang.Runnable#run()
 	 */
 	public void run () {
 
 		// Get the current model.
 		LogEventModel logEventModel = insightInstance.getController()
 				.getCurrentLogEventModel();
 		if (null == logEventModel) {
 			statusBar.setDisplayText(0, InsightConstants
 					.getLiteral("ERROR_NO_MODEL_LOADED"), false);
 		} else {
 
 			// Notify all listeners
 			for (Iterator mutatorListenerItr = mutatorListeners.iterator(); mutatorListenerItr
 					.hasNext();) {
 				((IMutatorListener) mutatorListenerItr.next()).startMutating(ILogEventModelMutator.NON_TAILING_MUTATOR);
 			}
 
 			boolean firstPageProcessed = false;
 
 			// Get the Page Set
 			PageSet pageSet = logEventModel.getPageSet();
 			Iterator pageSetIterator = pageSet.getPageSetIterator();
 
 			// Create the search result object and set it in the log event model
 			SearchResults searchResults = new SearchResults(insightInstance
 					.getController(), searchCriteria,
 					this.eventDetailsPresentation);
 			logEventModel.setSearchResults(searchResults);
 
 			if (indicateProgress) {
 				statusBar.setDisplayText(1, InsightConstants
 						.getLiteral("SEARCHING")
 						+ this.searchCriteria.getSearchString(), true);
 			}
 
 			// Process each page
 			long pageNum = 1;
 			long runningSerial = 0;
 			while (pageSetIterator.hasNext() && !stopSearch) {
 				IPage currentPage = (IPage) pageSetIterator.next();
 				List logEvents = currentPage.getLogEventList();
 
 				// Search each log event
 
 				for (Iterator logEventsIterator = logEvents.iterator(); logEventsIterator
 						.hasNext();) {
 					LogEvent logEvent = (LogEvent) logEventsIterator.next();
 					runningSerial++ ;
 					boolean matchFound = false;
 
 					if (searchCategory) {
 						if (matchString(logEvent.getLoggerName()) == true) {
 							matchFound = true;
 						}
 					}
 
 					if (searchExceptionClassName) {
 						if (matchString(logEvent.getExceptionName()) == true) {
 							matchFound = true;
 						}
 					}
 
 					if (searchMessage) {
 						if (matchString(logEvent.getMessage().toString()) == true) {
 							matchFound = true;
 						}
 					}
 
 					if (searchThread) {
 						if (matchString(logEvent.getThreadName()) == true) {
 							matchFound = true;
 						}
 					}
 
 					if (searchThrowable) {
 						String [] throwableString = logEvent
 								.getThrowableStrRep();
 						for (int i = 0; i < throwableString.length; i++ ) {
 							if (matchString(throwableString[i]) == true) {
 								matchFound = true;
 								break;
 							}
 						}
 					}
 
 					if (searchPriority) {
 						if (matchString(logEvent.getLevel().toString()) == true) {
 							matchFound = true;
 						}
 					}
 
 					if (searchNamespace) {
 						if (matchString(logEvent.getNamespace()
 								.getNamespaceAsString()) == true) {
 							matchFound = true;
 						}
 					}
 
 					// If a match if found, update status bar, add this to
 					// cache.
 					if (matchFound) {
 						if (indicateProgress) {
 							statusBar.setDisplayText(1, InsightConstants
 									.getLiteral("SEARCHING")
 									+ this.searchCriteria.getSearchString(),
 									true);
 						}
 						searchResults.addMatcingLogEvent(new MatchingLogEvent(
 								pageNum, runningSerial));
 					}
 				}
 
 				// If completed processing the first page, display that if
 				// matches found
 				if (!firstPageProcessed && matchCount > 0) {
 					// Set the display to the first page
 					searchResults.navigate(InsightConstants
 							.getLiteral("FIRST_SEARCH_MATCH"));
 					firstPageProcessed = true;
 				}
 
 				// The following line may degrade performance!
 				insightInstance.getController().setStatus();
 
 				// Go to the next page.
 				pageNum++ ;
 			}
 
 			// Clear the status bar progress
 			statusBar.clearDisplay(1);
 
 			if (matchCount == 0) {
 				if (indicateProgress) {
 					statusBar.setDisplayText(0, InsightConstants
 							.getLiteral("NO_MATCHES_FOUND"), false);
 				}
 			} else {
 				if (indicateProgress) {
 					statusBar.setDisplayText(0, InsightConstants
 							.getLiteral("SEARCH_COMPLETE")
 							+ searchResults.getCountOfMatchingLogEvents(),
 							false);
 				}
 			}
 
 			// Notify all listeners
 			for (Iterator mutatorListenerItr = mutatorListeners.iterator(); 
 					mutatorListenerItr.hasNext();) {
 				// The Event search provider returns a success message to all
 				// mutator listeners, irrespective of the presence of any match.
 				// This is because Event Search Provider is not strictly a
 				// mutator, and not finding a search match is not actually a
 				// failure.
 				((IMutatorListener) mutatorListenerItr.next())
 						.endMutating(ILogEventModelMutator.SUCCESS);
 			}
 		}
 	}
 
 	/**
 	 * Searches the string passed for the pattern.
 	 * 
 	 * @param stringToMatch String to match
 	 * @return <code>true</code> if a match is found, else <code>false</code>.
 	 */
 	private boolean matchString (String stringToMatch) {
 
 		boolean matchFound = false;
 		if (null == searchMatcher) {
 			searchMatcher = searchPattern.matcher(stringToMatch);
 		} else {
 			searchMatcher.reset(stringToMatch);
 		}
 
 		while (searchMatcher.find()) {
 			matchFound = true;
 			matchCount++ ;
 		}
 
 		return matchFound;
 	}
 
 	/**
 	 * @see com.mindtree.techworks.insight.model.ILogEventModelMutator#addMutatorListener(com.mindtree.techworks.insight.model.IMutatorListener)
 	 */
 	public void addMutatorListener (IMutatorListener mutatorListener) {
 
 		mutatorListeners.add(mutatorListener);
 
 	}
 
 	/**
 	 * @see com.mindtree.techworks.insight.model.ILogEventModelMutator#removeMutatorListener(com.mindtree.techworks.insight.model.IMutatorListener)
 	 */
 	public void removeMutatorListener (IMutatorListener mutatorListener) {
 
 		mutatorListeners.remove(mutatorListener);
 
 	}
 
 }