/*
 * Copyright (c) 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:
 *
 * Properties of a source document opened to Eclipse editor
 *
 */
package com.nokia.tracecompiler.engine.source;

import java.util.ArrayList;
import java.util.Iterator;

import com.nokia.tracecompiler.engine.TraceCompilerEngineConfiguration;
import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;
import com.nokia.tracecompiler.engine.TraceLocation;
import com.nokia.tracecompiler.model.TraceModel;
import com.nokia.tracecompiler.source.SourceDocumentFactory;
import com.nokia.tracecompiler.source.SourceDocumentInterface;
import com.nokia.tracecompiler.source.SourceIterator;
import com.nokia.tracecompiler.source.SourceParser;
import com.nokia.tracecompiler.source.SourceParserException;
import com.nokia.tracecompiler.source.SourcePropertyProvider;
import com.nokia.tracecompiler.source.SourceStringSearch;

/**
 * Properties of a source document which contains trace locations
 * 
 */
public class SourceProperties implements Iterable<TraceLocation> {

	/**
	 * Trace locations within the source
	 */
	private ArrayList<TraceLocation> locations = new ArrayList<TraceLocation>();

	/**
	 * Source parser
	 */
	private SourceParser sourceParser;

	/**
	 * Offset is stored in preProcess and reset in postProcess.
	 */
	private int firstChangedLocation = -1;

	/**
	 * Offset is stored in preProcess and reset in postProcess.
	 */
	private int firstUnchangedLocation = -1;

	/**
	 * The searchers for trace identifiers
	 */
	private ArrayList<SourceStringSearch> searchers = new ArrayList<SourceStringSearch>();

	/**
	 * Start index for calls to parseTrace
	 */
	private int searchStartIndex;

	/**
	 * Read-only flag
	 */
	private boolean readOnly;

	/**
	 * Creates source properties for given source document
	 * 
	 * @param model
	 *            the trace model
	 * @param framework
	 *            the document framework
	 * @param document
	 *            the document
	 */
	SourceProperties(TraceModel model, SourceDocumentFactory framework,
			SourceDocumentInterface document) {
		sourceParser = new SourceParser(framework, document);
		Iterator<SourceParserRule> parsers = model
				.getExtensions(SourceParserRule.class);
		while (parsers.hasNext()) {
			// The rule defines what to search and how to interpret the
			// parameters. It is stored into the searcher as search data
			addParserRule(parsers.next());
		}
	}

	/**
	 * Gets the source parser
	 * 
	 * @return the parser
	 */
	public SourceParser getSourceParser() {
		return sourceParser;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Iterable#iterator()
	 */
	public Iterator<TraceLocation> iterator() {
		return locations.iterator();
	}

	/**
	 * Gets the file name of this source
	 * 
	 * @return the name
	 */
	public String getFileName() {
		String retval = null;
		if (sourceParser != null) {
			SourceDocumentInterface source = sourceParser.getSource();
			if (source != null) {
				SourcePropertyProvider provider = source.getPropertyProvider();
				if (provider != null) {
					retval = provider.getFileName();
				}
			}
		}
		return retval;
	}

	/**
	 * Sets the read-only flag for this source. Traces cannot be added to
	 * read-only sources, but they can be parsed for data
	 * 
	 * @param readOnly
	 *            the read-only flag
	 */
	void setReadOnly(boolean readOnly) {
		this.readOnly = readOnly;
	}

	/**
	 * Gets the read-only flag
	 * 
	 * @return read-only flag
	 */
	public boolean isReadOnly() {
		return readOnly;
	}

	/**
	 * Source opened notification
	 */
	void sourceOpened() {
		updateTraces(0, sourceParser.getDataLength());
	}

	/**
	 * Parses the document starting from given offset and locates the trace
	 * entries from it. The first unchanged trace entry stops the search
	 * 
	 * @param startOffset
	 *            the offset where to start the search
	 * @param endOffset
	 *            the offset where to end the search
	 */
	private void updateTraces(int startOffset, int endOffset) {
		Iterator<SourceStringSearch> itr = searchers.iterator();
		while (itr.hasNext()) {
			SourceStringSearch searcher = itr.next();
			searcher.resetSearch(startOffset, endOffset);
			updateTraces(endOffset, searcher);
		}
	}

	/**
	 * Uses the given SourceSearch to parse traces
	 * 
	 * @param end
	 *            the offset where parser should stop
	 * @param searcher
	 *            the searcher
	 */
	private void updateTraces(int end, SourceStringSearch searcher) {
		int offset;
		searchStartIndex = 0;
		// If not updating, the entries contents are processed
		do {
			offset = searcher.findNext();
			try {
				if (offset != -1 && offset < end) {
					String tag = isValidTrace(offset, searcher
							.getSearchString().length(), searcher, false);
					if (tag != null) {
						parseTrace(offset, (SourceParserRule) searcher
								.getSearchData(), tag);
					}
				}
			} catch (SourceParserException e) {
				TraceLocation location = new TraceLocation(this, offset,
						offset + 80);
				TraceCompilerEngineGlobals
						.getEvents()
						.postErrorMessage(
								Messages
										.getString("SourceProperties.parsingArrowAtBeginText") + location.getFilePath() + location.getFileName() + Messages.getString("SourceProperties.parsingArrownAtMiddleText") + location.getLineNumber(), null, true); //$NON-NLS-1$ //$NON-NLS-2$
				// If the parameters cannot be parsed, the trace is
				// not added to the array
			}
		} while (offset != -1 && offset < end);
	}

	/**
	 * Parses a trace found from the document and adds it to the document's list
	 * of positions. The position updater keeps the trace location up-to-date.
	 * 
	 * @param offset
	 *            the offset to the trace
	 * @param parserRule
	 *            the parser to be attached to the location
	 * @param locationTag
	 *            the tag of the location
	 * @throws SourceParserException
	 *             if trace cannot be parsed
	 */
	private void parseTrace(int offset, SourceParserRule parserRule,
			String locationTag) throws SourceParserException {
		int arrayIndex = -1;
		// Checks the changed locations. If a matching offset if found, the
		// location is an existing one. In that case the location is not
		// added to the array. If an offset larger than the new offset is
		// found from the array, the location is inserted into that slot. If
		// all locations within the array are smaller than the new offset,
		// the new location is inserted before the first unchanged location.
		// Since the locations in the array are ordered, the checking can
		// always start from the latest location that has been found from
		// the array. The caller of this function must set
		// parseTraceStartIndex to 0 before starting a loop where this
		// function is called. If firstUnchangedLocation is -1, this is the
		// first time the file is being parsed and thus all locations are
		// checked
		boolean found = false;
		int searchEndIndex;
		int newSearchStartIndex = -1;
		if (firstUnchangedLocation >= 0) {
			searchEndIndex = firstUnchangedLocation;
		} else {
			searchEndIndex = locations.size();
		}
		for (int i = searchStartIndex; i < searchEndIndex && !found; i++) {
			TraceLocation location = locations.get(i);
			// Deleted locations are ignored. If a trace was replaced, the
			// new offset will match the offset of the deleted one.
			if (!location.isDeleted()) {
				// If the offset of the trace matches an existing offset,
				// the trace is old one. If the offset within the array is
				// larger than the source offset, the trace found from
				// source is new.
				if (location.getOffset() == offset) {
					found = true;
					// Starts the next search from the value following the
					// trace that was found
					searchStartIndex = i + 1;
					arrayIndex = -1;
				} else if (location.getOffset() > offset) {
					found = true;
					// A new trace will be added into the current index, so
					// the next search will start from the same location as
					// was checked now. The index is updated after the trace has
					// succesfully been created
					newSearchStartIndex = i + 1;
					arrayIndex = i;
				}
			}
		}
		// If trace was not found from the list, the trace is new and all
		// traces following it are also new. The start index is set to point
		// past the first unchanged location and thus the next search will
		// ignore the above loop.
		if (!found) {
			arrayIndex = searchEndIndex;
			searchStartIndex = firstUnchangedLocation + 1;
		}
		if (arrayIndex >= 0) {
			// Creates a new location if it was not found
			ArrayList<String> list = new ArrayList<String>();
			int endOfTrace = sourceParser
					.tokenizeParameters(offset, list, true);

			TraceLocation location = new TraceLocation(this, offset, endOfTrace
					- offset);

			// The parser rules have been associated with the searchers. The
			// parser rule that found the location is associated with the
			// location and used to process its parameters
			location.setTag(locationTag);
			location.setParserRule(parserRule);
			location.setData(list);

			TraceCompilerEngineGlobals
					.getEvents()
					.postInfoMessage(
							Messages
									.getString("SourceProperties.newTraceLocationFoundBeginText") + location.getFilePath() + location.getFileName() + Messages.getString("SourceProperties.newTraceLocationFoundMiddleText") + location.getLineNumber() + Messages.getString("SourceProperties.newTraceLocationFoundEndText") + location.getTraceText(), null); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			locations.add(arrayIndex, location);
			// The changed flag is set to newly added traces. If a location
			// is added prior to the first changed location, the index of first
			// changed location needs to be adjusted so that the flag gets
			// cleared in postprocessing. Also the index of first unchanged
			// location needs to be updated to reflect the changed array
			if (firstUnchangedLocation >= 0) {
				location.setContentChanged(true);
				if (arrayIndex < firstChangedLocation) {
					firstChangedLocation = arrayIndex;
				}
				firstUnchangedLocation++;
			}
			// Updates the search start index if trace creation was succesful
			if (newSearchStartIndex >= 0) {
				searchStartIndex = newSearchStartIndex;
			}
		}
	}

	/**
	 * Checks that a trace is valid
	 * 
	 * @param offset
	 *            offset to trace identifier
	 * @param length
	 *            length of trace
	 * @param searcher
	 *            the source searcher
	 * @param checkMainTag
	 *            true if the main search tag needs to be checked, false if only
	 *            the tag suffix is checked
	 * @return the trace tag or null if trace is not valid
	 */
	private String isValidTrace(int offset, int length,
			SourceStringSearch searcher, boolean checkMainTag) {
		String retval = null;
		try {
			int idlen = searcher.getSearchString().length();
			int idend = offset + idlen;
			if (checkMainTag) {
				if (length >= idlen
						&& searcher.isSearchStringMatch(sourceParser.getData(
								offset, idlen))) {
					// The previous character must be a separator or white space
					if (offset == 0
							|| !Character.isJavaIdentifierPart(sourceParser
									.getData(offset - 1))) {
						retval = getSearchTag(offset, idend);
					}
				}
			} else {
				// If main tag is not checked
				retval = getSearchTag(offset, idend);
			}
			retval = verifyTag(searcher, retval, idlen);
		} catch (Exception e) {
			if (TraceCompilerEngineConfiguration.ASSERTIONS_ENABLED) {
				TraceCompilerEngineGlobals.getEvents().postAssertionFailed(
						"Trace validity check failed", e); //$NON-NLS-1$
			}
		}
		return retval;
	}

	/**
	 * Verifies the tag against tag suffixes from parser
	 * 
	 * @param searcher
	 *            the searcher
	 * @param tag
	 *            the tag include main tag and suffix
	 * @param idlen
	 *            the length of the main tag
	 * @return the tag if it is valid, null if not
	 */
	private String verifyTag(SourceStringSearch searcher, String tag, int idlen) {
		if (tag != null) {
			// The trace suffix is verified by the parser. For example, if
			// search data is "SymbianTrace" and the tag found from source
			// is "SymbianTraceData1", the parser checks if "Data1" is a
			// valid trace tag suffix.
			if (!((SourceParserRule) searcher.getSearchData())
					.isAllowedTagSuffix(tag.substring(idlen))) {
				tag = null;
			}
		}
		return tag;
	}

	/**
	 * Gets the search tag between offset and next '(' character
	 * 
	 * @param offset
	 *            the start of tag
	 * @param idend
	 *            the end of tag
	 * @return the tag
	 * @throws SourceParserException
	 *             if parser fails
	 */
	private String getSearchTag(int offset, int idend)
			throws SourceParserException {
		// Locates the parameters starting from trace identifier
		String retval = null;
		SourceIterator srcitr = sourceParser.createIterator(idend - 1,
				SourceParser.SKIP_ALL);
		boolean found = false;
		while (srcitr.hasNext() && !found) {
			char c = srcitr.next();
			if (c == ';') {
				// Trace must have parameters
				found = true;
			} else if (c == '(') {
				found = true;
				// Stores the tag into location
				retval = sourceParser.getData(offset, srcitr.previousIndex()
						- offset + 1);
			} else if (srcitr.hasSkipped()) {
				// White spaces are not allowed within trace tag
				found = true;
			}
		}
		return retval;
	}

	/**
	 * Checks if a trace can be inserted into given location
	 * 
	 * @param offset
	 *            the offset to the location
	 * @return true if location is valid
	 */
	boolean checkInsertLocation(int offset) {
		boolean retval = true;
		try {
			offset = sourceParser.findStartOfLine(offset, false, true);
			if (sourceParser.isInExcludedArea(offset)) {
				retval = false;
			}
		} catch (SourceParserException e) {
			retval = false;
		}
		return retval;
	}

	/**
	 * Adds a new parser
	 * 
	 * @param rule
	 *            the new parser rule
	 */
	void addParserRule(SourceParserRule rule) {
		SourceStringSearch searcher = sourceParser.startStringSearch(rule
				.getSearchTag(), 0, -1, SourceParser.MATCH_WORD_BEGINNING
				| SourceParser.SKIP_ALL);
		searcher.setSearchData(rule);
		searchers.add(searcher);
	}

}