/*

 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 * SearchProcessor DataProcessor

 *

 */

package com.nokia.traceviewer.engine.dataprocessor;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.FindReplaceDocumentAdapter;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IRegion;

import org.eclipse.ui.PlatformUI;

import com.nokia.traceviewer.action.TraceViewerActionUtils;

import com.nokia.traceviewer.dialog.SearchDialog;

import com.nokia.traceviewer.engine.DataProcessorAccess;

import com.nokia.traceviewer.engine.DataReader;

import com.nokia.traceviewer.engine.DataScrollReader;

import com.nokia.traceviewer.engine.MediaCallback;

import com.nokia.traceviewer.engine.StateHolder;

import com.nokia.traceviewer.engine.TraceInformation;

import com.nokia.traceviewer.engine.TraceProperties;

import com.nokia.traceviewer.engine.TraceViewerGlobals;

import com.nokia.traceviewer.engine.TraceViewerDialogInterface.Dialog;

/**

 * SearchProcessor DataProcessor

 */

public final class SearchProcessor implements DataProcessor, MediaCallback {

	/**

	 * Enum indicating the error codes of TraceViewer API operations

	 */

	public enum TimestampSearchPhase {

		/**

		 * Timestamp search is not ongoing

		 */

		NONE,

		/**

		 * Finding end timestamp

		 */

		FINDING_END,

		/**

		 * End found

		 */

		END_FOUND;

	}

	/**

	 * Search dialog used in searching

	 */

	private SearchDialog searchDialog;

	/**

	 * Temporary document used in searching

	 */

	private final IDocument document;

	/**

	 * Buffer to hold data before inserting all to document

	 */

	private final StringBuffer data;

	/**

	 * Finder adapter

	 */

	private final FindReplaceDocumentAdapter finder;

	/**

	 * Search properties

	 */

	private SearchProperties searchProperties;

	/**

	 * Timestamp range end trace number

	 */

	private int timestampEndTrace;

	/**

	 * Tells if we have hit EOF already

	 */

	private boolean hitEOFAlready;

	/**

	 * Tells that we should stop searching

	 */

	private boolean stopSearching;

	/**

	 * Tells that search is ongoing

	 */

	private boolean searchOngoing;

	/**

	 * Array containing trace informations (cid, gid and tid)

	 */

	private final List<TraceInformation> traceInformations;

	/**

	 * Array containing timestamp strings

	 */

	private final List<String> timestampStrings;

	/**

	 * Search data reader

	 */

	private DataScrollReader searchDataReader;

	/**

	 * Timestamp search phase

	 */

	private TimestampSearchPhase timestampSearchPhase = TimestampSearchPhase.NONE;

	/**

	 * Constructor

	 */

	public SearchProcessor() {

		// Create needed elements and arrays

		data = new StringBuffer();

		document = new Document();

		finder = new FindReplaceDocumentAdapter(document);

		searchProperties = new SearchProperties();

		traceInformations = new ArrayList<TraceInformation>();

		timestampStrings = new ArrayList<String>();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * com.nokia.traceviewer.engine.DataProcessor#processData(com.nokia.traceviewer

	 * .engine.TraceProperties)

	 */

	public void processData(TraceProperties properties) {

		DataProcessorAccess dpa = TraceViewerGlobals.getTraceViewer()

				.getDataProcessorAccess();

		// If binary trace, decode it

		if (properties.binaryTrace) {

			dpa.getDecoder().processData(properties);

		}

		// Parse timestamp

		dpa.getTimestampParser().processData(properties);

		// Traces missing

		if (properties.bTraceInformation.isTraceMissing()) {

			data.append(TraceViewerActionUtils.TRACES_DROPPED_MSG);

		}

		// Timestamp string

		if (properties.timestampString != null) {

			data.append(properties.timestampString);

			data.append(dpa.getTimestampParser().getTimeFromPreviousString(

					properties.timeFromPreviousTrace));

			data.append('\t');

			// Add to the timestampstrings array

			timestampStrings.add(properties.timestampString);

		}

		// Trace string

		data.append(properties.traceString);

		// Trace comment

		if (properties.traceComment != null) {

			data.append(TraceViewerActionUtils.COMMENT_PREFIX);

			data.append(properties.traceComment);

		}

		data.append('\n');

		traceInformations.add(properties.information);

		// Last trace, start search

		if (properties.lastTrace) {

			document.set(data.toString());

			data.setLength(0);

			// Data is received, start search

			startSearch();

			traceInformations.clear();

			timestampStrings.clear();

		}

	}

	/**

	 * Starts search

	 */

	private void startSearch() {

		if (!stopSearching) {

			try {

				int tracesTillNow = searchProperties

						.getCurrentSearchStartLine()

						+ TraceViewerGlobals.blockSize * 2;

				// Get the search start offset

				int searchStartOffset = getSearchStartOffset();

				// Find the trace and get the offset of it

				int offset = findTrace(searchStartOffset);

				// Update progressBar

				searchDialog.updateSearchProgressBar(searchProperties

						.getCurrentSearchStartLine() + 1);

				if (searchProperties.isSearchingForward()) {

					processSearchingForward(tracesTillNow, offset);

				} else {

					processSearchingBackward(offset);

				}

			} catch (BadLocationException e) {

				e.printStackTrace();

				searchOngoing = false;

			}

		} else {

			TraceViewerGlobals.getTraceViewer().getStateHolder().setState(

					StateHolder.State.NORMAL);

			stopSearching = false;

			searchOngoing = false;

		}

	}

	/**

	 * Gets the correct search start offset

	 * 

	 * @return search start offset

	 */

	private int getSearchStartOffset() {

		int searchStartOffset;

		// Set proper offset to start searching from

		if (searchProperties.isSearchingForward()) {

			searchStartOffset = 0;

			// Searching backward

		} else {

			searchStartOffset = document.getLength() - 1;

		}

		return searchStartOffset;

	}

	/**

	 * Finds the trace using search properties

	 * 

	 * @param searchStartOffset

	 *            start offset where to start the search

	 * @return offset of the trace found or -1 if not found

	 * @throws BadLocationException

	 */

	private int findTrace(int searchStartOffset) throws BadLocationException {

		int offset = SearchUtils.NOT_FOUND;

		// Search using component, group and trace ID's

		if (SearchUtils.containsIdQuery(searchProperties.getSearchString())) {

			offset = findTraceIDSearch(searchStartOffset);

			// Timestamp search

		} else if (SearchUtils.containsTimestampQuery(searchProperties

				.getSearchString())) {

			offset = findTraceTimestampSearch(searchStartOffset);

			// Create a normal text search

		} else {

			timestampSearchPhase = TimestampSearchPhase.NONE;

			IRegion region = finder.find(searchStartOffset, searchProperties

					.getSearchString(), searchProperties.isSearchingForward(),

					searchProperties.isCaseSensitive(), searchProperties

							.isWholeWord(), searchProperties.isRegExp());

			if (region != null) {

				offset = region.getOffset();

			}

		}

		return offset;

	}

	/**

	 * Finds the trace using ID search

	 * 

	 * @param searchStartOffset

	 *            search start offset

	 * @return found offset

	 * @throws BadLocationException

	 */

	private int findTraceIDSearch(int searchStartOffset)

			throws BadLocationException {

		int offset;

		timestampSearchPhase = TimestampSearchPhase.NONE;

		// Parse ID's from the search string

		TraceInformation inf = SearchUtils.parseIDsFromString(searchProperties

				.getSearchString());

		int startTrace = document.getLineOfOffset(searchStartOffset);

		// Get the trace number that matches the ID's

		int foundTrace = SearchUtils.findTraceOffsetFromInformations(

				startTrace, inf, traceInformations, searchProperties

						.isSearchingForward());

		if (foundTrace == SearchUtils.NOT_FOUND) {

			offset = SearchUtils.NOT_FOUND;

		} else {

			offset = document.getLineOffset(foundTrace);

		}

		return offset;

	}

	/**

	 * Finds the trace using timestamp search

	 * 

	 * @param searchStartOffset

	 *            search start offset

	 * @return found offset

	 * @throws BadLocationException

	 */

	private int findTraceTimestampSearch(int searchStartOffset)

			throws BadLocationException {

		int offset;

		boolean getFirstTimestamp = true;

		boolean timestampSearchOnGoing = false;

		if (timestampSearchPhase == TimestampSearchPhase.NONE

				|| timestampSearchPhase == TimestampSearchPhase.FINDING_END) {

			timestampSearchOnGoing = true;

		}

		if (SearchUtils.containsTimestampRangeQuery(searchProperties

				.getSearchString())

				&& timestampSearchOnGoing) {

			getFirstTimestamp = false;

			timestampSearchPhase = TimestampSearchPhase.FINDING_END;

		}

		// Parse timestamp from the search string

		String timestamp = SearchUtils.parseTimestampFromString(

				searchProperties.getSearchString(), getFirstTimestamp);

		int startTrace = document.getLineOfOffset(searchStartOffset);

		// Get the trace which matches the timestamp

		int foundTrace = SearchUtils.findTraceOffsetFromTimestamps(startTrace,

				timestamp, timestampStrings, searchProperties

						.isSearchingForward());

		if (foundTrace == SearchUtils.NOT_FOUND) {

			offset = SearchUtils.NOT_FOUND;

		} else {

			offset = document.getLineOffset(foundTrace);

		}

		return offset;

	}

	/**

	 * Processes situation when searching forward

	 * 

	 * @param tracesTillNow

	 *            Tells how many traces is read from file

	 * @param offset

	 *            offset to found item

	 * @throws BadLocationException

	 */

	private void processSearchingForward(int tracesTillNow, int offset)

			throws BadLocationException {

		// String found

		if (offset != SearchUtils.NOT_FOUND) {

			processStringFound(offset);

			// Full round processed

		} else if (tracesTillNow > searchProperties

				.getOriginalSearchStartLine()

				&& hitEOFAlready) {

			fullRoundProcessed();

			// We didn't find anything from these 2 blocks, go to next one

		} else {

			// Not End Of File

			if (tracesTillNow < TraceViewerGlobals.getTraceViewer()

					.getDataReaderAccess().getCurrentDataReader()

					.getTraceCount()) {

				searchProperties.setCurrentSearchStartLine(tracesTillNow + 1);

				processSearch(searchProperties, true);

				// End Of File

			} else {

				hitEOFAlready = true;

				searchDialog.updateSearchProgressBar(TraceViewerGlobals

						.getTraceViewer().getDataReaderAccess()

						.getCurrentDataReader().getTraceCount());

				searchDialog.searchHitEOF();

				searchOngoing = false;

			}

		}

	}

	/**

	 * Full round processed

	 */

	private void fullRoundProcessed() {

		hitEOFAlready = false;

		searchDialog.updateSearchProgressBar(searchProperties

				.getOriginalSearchStartLine());

		searchDialog.searchHitFullRound();

		searchOngoing = false;

	}

	/**

	 * Processes situation where result was found

	 * 

	 * @param offset

	 *            offset of the result

	 * @throws BadLocationException

	 */

	private void processStringFound(int offset) throws BadLocationException {

		hitEOFAlready = false;

		int line = document.getLineOfOffset(offset);

		int foundTraceLine = searchProperties.getCurrentSearchStartLine()

				+ line;

		// Update progressBar

		searchDialog.updateSearchProgressBar(foundTraceLine);

		// Set the search line

		if (timestampSearchPhase == TimestampSearchPhase.NONE) {

			searchOngoing = false;

			TraceViewerGlobals.getTraceViewer().getView().highlightLines(

					foundTraceLine, 0, false);

			// Timestamp range search

		} else {

			if (timestampSearchPhase == TimestampSearchPhase.FINDING_END) {

				timestampSearchPhase = TimestampSearchPhase.END_FOUND;

				timestampEndTrace = foundTraceLine;

				// Start new search

				searchProperties.setCurrentSearchStartLine(foundTraceLine);

				processSearch(searchProperties, true);

				// End and start both found

			} else if (timestampSearchPhase == TimestampSearchPhase.END_FOUND) {

				searchOngoing = false;

				TraceViewerGlobals.getTraceViewer().getView().highlightLines(

						foundTraceLine, timestampEndTrace, true);

				timestampSearchPhase = TimestampSearchPhase.NONE;

				timestampEndTrace = 0;

			} else {

				searchOngoing = false;

			}

		}

	}

	/**

	 * Processes situation when searching backwards

	 * 

	 * @param offset

	 *            offset to found item

	 * @throws BadLocationException

	 */

	private void processSearchingBackward(int offset)

			throws BadLocationException {

		// String found

		if (offset != SearchUtils.NOT_FOUND) {

			processStringFound(offset);

			// Full round processed

		} else if (searchProperties.getCurrentSearchStartLine() <= searchProperties

				.getOriginalSearchStartLine()

				&& hitEOFAlready) {

			fullRoundProcessed();

		} else {

			// Not End Of File

			if (searchProperties.getCurrentSearchStartLine() > 0) {

				searchProperties.setCurrentSearchStartLine(searchProperties

						.getCurrentSearchStartLine()

						- (TraceViewerGlobals.blockSize / 2));

				processSearch(searchProperties, true);

				// End Of File

			} else {

				hitEOFAlready = true;

				searchDialog.updateSearchProgressBar(0);

				// Timestamp search

				if (timestampSearchPhase == TimestampSearchPhase.END_FOUND

						|| timestampSearchPhase == TimestampSearchPhase.FINDING_END) {

					if (timestampEndTrace == 0) {

						timestampEndTrace--;

					}

					TraceViewerGlobals.getTraceViewer().getView()

							.highlightLines(0, timestampEndTrace + 1, false);

					timestampSearchPhase = TimestampSearchPhase.NONE;

					timestampEndTrace = 0;

					// Normal search

				} else {

					searchDialog.searchHitEOF();

				}

				searchOngoing = false;

			}

		}

	}

	/**

	 * Sets hitEOFAlready variable

	 * 

	 * @param hitEOF