/*
 * 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:
 *
 * Search utils
 *
 */
package com.nokia.traceviewer.engine.dataprocessor;

import java.util.List;

import com.nokia.traceviewer.engine.TraceInformation;

/**
 * Search utils
 */
public final class SearchUtils {

	/**
	 * Empty String
	 */
	public static final String EMPTY = ""; //$NON-NLS-1$

	/**
	 * Dash string
	 */
	private static final String DASH = "-"; //$NON-NLS-1$

	/**
	 * Indicates not found
	 */
	public static final int NOT_FOUND = -1;

	/**
	 * Semicolon
	 */
	private static final char SEMICOLON = ';';

	/**
	 * Component ID String
	 */
	private static final String CID_STR = "cid:"; //$NON-NLS-1$

	/**
	 * Group ID String
	 */
	private static final String GID_STR = "gid:"; //$NON-NLS-1$

	/**
	 * Trace ID String
	 */
	private static final String TID_STR = "tid:"; //$NON-NLS-1$

	/**
	 * Timestamp String
	 */
	private static final String TIMESTAMP_STR = "{timestamp_srch}:"; //$NON-NLS-1$

	/**
	 * Parses trace information class from the seach string
	 * 
	 * @param searchStr
	 *            the search string
	 * @return trace information containing cid, gid and tid
	 */
	public static TraceInformation parseIDsFromString(String searchStr) {
		TraceInformation inf = new TraceInformation();

		// Parse component ID
		int cidIndex = searchStr.indexOf(CID_STR);
		String cidStr = searchStr.substring(cidIndex + CID_STR.length(),
				searchStr.indexOf(SEMICOLON, cidIndex));
		int cid = Integer.parseInt(cidStr);

		// Parse group ID
		int gidIndex = searchStr.indexOf(GID_STR);
		String gidStr = searchStr.substring(gidIndex + GID_STR.length(),
				searchStr.indexOf(SEMICOLON, gidIndex));
		int gid = Integer.parseInt(gidStr);
		searchStr = searchStr.substring(searchStr.indexOf(SEMICOLON) + 1);

		// Parse trace ID
		int tidIndex = searchStr.indexOf(TID_STR);
		String tidStr = searchStr.substring(tidIndex + TID_STR.length(),
				searchStr.indexOf(SEMICOLON, tidIndex));
		int tid = Integer.parseInt(tidStr);

		// Set ID's and return
		inf.setComponentId(cid);
		inf.setGroupId(gid);
		inf.setTraceId(tid);

		return inf;
	}

	/**
	 * Parses searchable timestamp from the seach string
	 * 
	 * @param searchStr
	 *            the search string
	 * @param getFirstTimestamp
	 *            if true, get first timestamp. If false, get second timestamp
	 * @return searchable timestamp
	 */
	public static String parseTimestampFromString(String searchStr,
			boolean getFirstTimestamp) {

		int timestampStartIndex = searchStr.indexOf(TIMESTAMP_STR);
		int startIndex = timestampStartIndex + TIMESTAMP_STR.length();
		int endIndex = searchStr.length();

		int dashIndex = searchStr.indexOf(DASH);
		if (dashIndex != -1) {

			// Get first timestamp
			if (getFirstTimestamp) {
				endIndex = dashIndex;
			} else {
				startIndex = dashIndex + 1;
			}
		}

		// Parse timestamp
		String timestampStr = searchStr.substring(startIndex, endIndex);

		return timestampStr;
	}

	/**
	 * Finds trace line from informations array
	 * 
	 * @param startTrace
	 *            start trace where to start search
	 * @param inf
	 *            trace information to search for
	 * @param informations
	 *            trace informations arraylist
	 * @param searchForward
	 *            if true, search forward. Otherwise search backward
	 * @return line of found trace or -1 if not found
	 */
	public static int findTraceOffsetFromInformations(int startTrace,
			TraceInformation inf, List<TraceInformation> informations,
			boolean searchForward) {
		int line = NOT_FOUND;

		// Search forward
		if (searchForward && informations != null) {
			// Start from start line and go through ID's
			for (int i = startTrace; i < informations.size(); i++) {
				TraceInformation listInf = informations.get(i);
				if (idsMatch(inf, listInf)) {
					line = i;
					break;
				}
			}

			// Search backwards
		} else if (informations != null) {
			// Start from start line and go through ID's backwards
			for (int i = startTrace; i >= 0; i--) {
				TraceInformation listInf = informations.get(i);
				if (idsMatch(inf, listInf)) {
					line = i;
					break;
				}
			}
		}

		return line;
	}

	/**
	 * Finds trace line from timestamps array
	 * 
	 * @param startTrace
	 *            start trace where to start search
	 * @param timestamp
	 *            timestamp to search for
	 * @param timestamps
	 *            timestamps arraylist
	 * @param searchForward
	 *            if true, search forward. Otherwise search backward
	 * @return line of found trace or -1 if not found
	 */
	public static int findTraceOffsetFromTimestamps(int startTrace,
			String timestamp, List<String> timestamps, boolean searchForward) {
		int line = NOT_FOUND;

		// Search forward
		if (searchForward && timestamps != null) {

			// Start from start line and go through timestamps
			for (int i = startTrace; i < timestamps.size(); i++) {
				if (i < timestamps.size()) {
					String ts = timestamps.get(i);
					if (ts.compareTo(timestamp) >= 0) {
						line = i;
						break;
					}
				}
			}

			// Search backwards
		} else if (timestamps != null) {
			// Start from start line and go through timestamps backwards
			for (int i = startTrace; i >= 0; i--) {
				if (i < timestamps.size()) {
					String ts = timestamps.get(i);
					if (ts.compareTo(timestamp) <= 0) {
						line = i;
						break;
					}
				}
			}
		}

		return line;
	}

	/**
	 * Checks if all ID's match
	 * 
	 * @param inf
	 *            first ID list
	 * @param listInf
	 *            second ID list
	 * @return true if all ID's match
	 */
	private static boolean idsMatch(TraceInformation inf,
			TraceInformation listInf) {
		return listInf.getComponentId() == inf.getComponentId()
				&& listInf.getGroupId() == inf.getGroupId()
				&& listInf.getTraceId() == inf.getTraceId();
	}

	/**
	 * Checks does the search string contain ID query
	 * 
	 * @param searchString
	 *            the search string
	 * @return true if search string contains ID query
	 */
	public static boolean containsIdQuery(String searchString) {
		boolean containsIdQuery = false;

		// Check that string contains cid, gid and tid strings
		if (searchString.contains(CID_STR) && searchString.contains(GID_STR)
				&& searchString.contains(TID_STR)) {

			// Parse ID's as strings
			int cidIdx = searchString.indexOf(CID_STR);
			String cid = searchString.substring(cidIdx + CID_STR.length(),
					searchString.indexOf(SEMICOLON, cidIdx));
			int gidIdx = searchString.indexOf(GID_STR);
			String gid = searchString.substring(gidIdx + GID_STR.length(),
					searchString.indexOf(SEMICOLON, gidIdx));
			int tidIdx = searchString.indexOf(TID_STR);
			String tid = searchString.substring(tidIdx + TID_STR.length(),
					searchString.indexOf(SEMICOLON, tidIdx));

			// Check that ID's are real integers
			if (!cid.equals(EMPTY) && !gid.equals(EMPTY) && !tid.equals(EMPTY)) {
				try {
					Integer.parseInt(cid);
					Integer.parseInt(gid);
					Integer.parseInt(tid);
					containsIdQuery = true;
				} catch (NumberFormatException e) {
					containsIdQuery = false;
				}
			}
		}

		return containsIdQuery;
	}

	/**
	 * Checks does the search string contain timestamp query
	 * 
	 * @param searchString
	 *            the search string
	 * @return true if search string contains timestamp query
	 */
	public static boolean containsTimestampQuery(String searchString) {
		boolean containsTimestampQuery = false;

		// Check that string contains timestamp strings
		if (searchString.contains(TIMESTAMP_STR)) {
			containsTimestampQuery = true;
		}

		return containsTimestampQuery;
	}

	/**
	 * Checks does the search string contain timestamp range query. User should
	 * first call "containsTimestampQuery" before this to actually ensure this
	 * is timestamp range query.
	 * 
	 * @param searchString
	 *            the search string
	 * @return true if search string contains timestamp query
	 */
	public static boolean containsTimestampRangeQuery(String searchString) {
		boolean containsTimestampRangeQuery = false;

		// Check that string contains timestamp range string
		int dashIndex = searchString.indexOf(DASH);
		if (dashIndex != -1 && searchString.length() > dashIndex + 1) {
			containsTimestampRangeQuery = true;
		}

		return containsTimestampRangeQuery;
	}

	/**
	 * Creates a search string from ID's
	 * 
	 * @param cid
	 *            Component ID
	 * @param gid
	 *            Group ID
	 * @param tid
	 *            Trace ID
	 * @return a search string that can be used to search with ID's
	 */
	public static String createStringFromIDs(int cid, int gid, int tid) {
		StringBuffer buf = new StringBuffer();
		// Add component ID
		buf.append(CID_STR);
		buf.append(cid);
		buf.append(SEMICOLON);

		// Add group ID
		buf.append(GID_STR);
		buf.append(gid);
		buf.append(SEMICOLON);

		// Add trace ID
		buf.append(TID_STR);
		buf.append(tid);
		buf.append(SEMICOLON);

		return buf.toString();
	}

	/**
	 * Creates a search string from timestamp
	 * 
	 * @param startTimestamp
	 *            start timestamp
	 * @param endTimestamp
	 *            end timestamp
	 * @return a search string that can be used to search with timestamp
	 */
	public static String createStringFromTimestamp(String startTimestamp,
			String endTimestamp) {
		StringBuffer buf = new StringBuffer();

		// Add start timestamp
		buf.append(TIMESTAMP_STR);
		buf.append(startTimestamp);

		// If end timestamp exists, add it
		if (endTimestamp != null) {
			buf.append(DASH);
			buf.append(endTimestamp);
		}

		return buf.toString();
	}
}