/*
* Copyright (c) 2007 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:
*
* Represents a location of a trace within a source document
*
*/
package com.nokia.tracecompiler.engine;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import com.nokia.tracecompiler.engine.TraceCompilerEngineErrorCodes.TraceCompilerErrorCode;
import com.nokia.tracecompiler.engine.source.SourceParserResult;
import com.nokia.tracecompiler.engine.source.SourceParserRule;
import com.nokia.tracecompiler.engine.source.SourceProperties;
import com.nokia.tracecompiler.model.Trace;
import com.nokia.tracecompiler.model.TraceCompilerErrorParameters;
import com.nokia.tracecompiler.model.TraceCompilerException;
import com.nokia.tracecompiler.model.TraceObject;
import com.nokia.tracecompiler.source.SourceConstants;
import com.nokia.tracecompiler.source.SourceLocation;
import com.nokia.tracecompiler.source.SourceLocationListener;

/**
 * Represents a location of a trace within a source document. The locations of a
 * document are updated by TraceLocationUpdater when document is changed
 * 
 */
public class TraceLocation extends SourceLocation implements LocationProperties {

	/**
	 * Source which owns this location
	 */
	private SourceProperties source;

	/**
	 * Name of the trace as parsed from source
	 */
	private String originalName;

	/**
	 * Name after conversion to valid trace name
	 */
	private String convertedName;

	/**
	 * Text of the trace as parsed from source
	 */
	private String traceText;

	/**
	 * The tag of the parser that found this trace location
	 */
	private String tag;

	/**
	 * Content changed flag
	 */
	private boolean contentChanged;

	/**
	 * Name changed flag
	 */
	private boolean nameChanged;

	/**
	 * The location list
	 */
	private TraceLocationList list;

	/**
	 * The parameters
	 */
	private List<String> parameters;

	/**
	 * Parser-specific data associated with this location
	 */
	private List<String> parserData;

	/**
	 * Rule which defines how the parameters found from source are interpreted
	 */
	private SourceParserRule parserRule;

	/**
	 * Flag, which determines if this location has changed after last convert
	 * operation
	 */
	private boolean changedAfterConvert = true;

	/**
	 * Last notified validity code
	 */
	private TraceCompilerErrorCode notifiedValidity = TraceCompilerErrorCode.OK;

	/**
	 * Last notified validity parameters
	 */
	private TraceCompilerErrorParameters notifiedValidityParameters;

	/**
	 * Parser error code
	 */
	private TraceCompilerErrorCode parserErrorCode = TraceCompilerErrorCode.OK;

	/**
	 * Parser error parameters
	 */
	private TraceCompilerErrorParameters parserErrorParameters;

	/**
	 * Converter error code
	 */
	private TraceCompilerErrorCode converterErrorCode = TraceCompilerErrorCode.OK;

	/**
	 * Converter error parameters
	 */
	private TraceCompilerErrorParameters converterErrorParameters;

	/**
	 * Creates a new location
	 * 
	 * @param source
	 *            the source where the location is associated
	 * @param offset
	 *            the offset to the trace within the source document
	 * @param length
	 *            the length of the trace
	 */
	public TraceLocation(SourceProperties source, int offset, int length) {
		super(source.getSourceParser(), offset, length);
		this.source = source;
	}

	/**
	 * Sets the content changed flag. If <i>changed</i> is false this also sets
	 * the name changed flag to false
	 * 
	 * @param changed
	 *            the new changed flag
	 */
	public void setContentChanged(boolean changed) {
		this.contentChanged = changed;
		if (!changed) {
			nameChanged = false;
		}
	}

	/**
	 * Checks if the content has changed.
	 * 
	 * @return the content changed flag
	 */
	public boolean isContentChanged() {
		return contentChanged;
	}

	/**
	 * Checks if the name has changed.
	 * 
	 * @return the name changed flag
	 */
	public boolean isNameChanged() {
		return contentChanged && nameChanged;
	}

	/**
	 * Gets the trace this location is associated to or null if unrelated
	 * 
	 * @return the trace
	 */
	public Trace getTrace() {
		Trace retval = null;
		if (list != null) {
			TraceObject object = list.getOwner();
			if (object instanceof Trace) {
				retval = (Trace) object;
			}
		}
		return retval;
	}

	/**
	 * Gets the name of the trace as parsed from source
	 * 
	 * @return the name of the trace
	 */
	public String getOriginalName() {
		return originalName;
	}

	/**
	 * Gets the name of the trace after conversion to valid name
	 * 
	 * @return the name of the trace
	 */
	public String getConvertedName() {
		return convertedName;
	}

	/**
	 * Gets the text of the trace
	 * 
	 * @return the text of the trace
	 */
	public String getTraceText() {
		return traceText;
	}

	/**
	 * Returns the source properties this location belongs to
	 * 
	 * @return source properties
	 */
	public SourceProperties getSource() {
		return source;
	}

	/**
	 * Sets the location list which owns this location
	 * 
	 * @param list
	 *            the location list
	 */
	public void setLocationList(TraceLocationList list) {
		this.list = list;
	}

	/**
	 * Gets the location list this location belongs to
	 * 
	 * @return the list
	 */
	public TraceLocationList getLocationList() {
		return list;
	}

	/**
	 * Sets the parser rule that will be used to parse the data of this
	 * location. Must be called before setData
	 * 
	 * @param rule
	 *            the rule used to parse the data
	 */
	public void setParserRule(SourceParserRule rule) {
		parserRule = rule;
	}

	/**
	 * Gets the parser rule that found this location
	 * 
	 * @return the parser rule
	 */
	public SourceParserRule getParserRule() {
		return parserRule;
	}

	/**
	 * Sets the trace tag that was found from source
	 * 
	 * @param tag
	 *            the trace tag
	 */
	public void setTag(String tag) {
		this.tag = tag;
	}

	/**
	 * Gets the trace tag
	 * 
	 * @return the tag
	 */
	public String getTag() {
		return tag;
	}

	/**
	 * Sets the trace data
	 * 
	 * @param list
	 *            the list of parameters
	 */
	public void setData(ArrayList<String> list) {
		try {
			SourceParserResult result = parserRule.parseParameters(tag, list);
			setData(result.originalName, result.convertedName,
					result.traceText, result.parameters, result.parserData);
			parserRule.getLocationParser().processNewLocation(this);
			parserErrorCode = TraceCompilerErrorCode.OK;
			parserErrorParameters = null;
			converterErrorCode = TraceCompilerErrorCode.OK;
			converterErrorParameters = null;
		} catch (TraceCompilerException e) {
			parserErrorCode = (TraceCompilerErrorCode) e.getErrorCode();
			parserErrorParameters = e.getErrorParameters();
		}
	}

	/**
	 * Sets the trace name and parameter list
	 * 
	 * @param originalName
	 *            the name parsed from source
	 * @param convertedName
	 *            the name after conversion
	 * @param traceText
	 *            the text parsed from source
	 * @param parameters
	 *            the list of parameters parsed from source
	 * @param parserData
	 *            list of parser-specific data
	 */
	private void setData(String originalName, String convertedName,
			String traceText, List<String> parameters, List<String> parserData) {
		if (!convertedName.equals(this.convertedName)) {
			this.convertedName = convertedName;
			nameChanged = true;
		}
		this.originalName = originalName;
		//remove line feed if the trace text spans multiple lines.
		if (traceText != null ) {
			this.traceText = traceText.replaceAll(SourceConstants.LINE_FEED, ""); //$NON-NLS-1$ //$NON-NLS-2$
		}
		this.parameters = parameters;
		this.parserData = parserData;
	}

	/**
	 * Removes the parameter at given index
	 * 
	 * @param index
	 *            the index
	 */
	public void removeParameterAt(int index) {
		// NOTE: Does not cause validity callbacks
		// This is currently only used temporarily when removing a parameter
		// from trace. This is needed to correctly update the source code
		if (parameters != null && index >= 0 && index < parameters.size()) {
			parameters.remove(index);
		}
	}

	/**
	 * Gets the number of parameters found from the source code
	 * 
	 * @return the number of parameters
	 */
	public int getParameterCount() {
		return parameters != null ? parameters.size() : 0;
	}

	/**
	 * Gets the parameter at given index
	 * 
	 * @param index
	 *            the parameter index
	 * @return the parameter at the index
	 */
	public String getParameter(int index) {
		return parameters.get(index);
	}

	/**
	 * Gets the parameters
	 * 
	 * @return iterator over the parameters
	 */
	public Iterator<String> getParameters() {
		List<String> list = null;
		if (parameters != null) {
			list = parameters;
		} else {
			list = Collections.emptyList();
		}
		return list.iterator();
	}

	/**
	 * Gets the parser-specific data
	 * 
	 * @return the parser data
	 */
	public List<String> getParserData() {
		return parserData;
	}

	/**
	 * Gets the current location validity code.
	 * 
	 * @return the validity code
	 */
	public TraceCompilerErrorCode getValidityCode() {
		return notifiedValidity;
	}

	/**
	 * Gets the parameters associated with the current location validity code.
	 * 
	 * @return the validity code
	 */
	public TraceCompilerErrorParameters getValidityParameters() {
		return notifiedValidityParameters;
	}

	/**
	 * Creates a notification if validity has changed. This is initially called
	 * from the location list when a location is added to it and after that from
	 * notifyLocationChanged.
	 */
	void runValidityCheck() {
		TraceCompilerErrorCode code;
		TraceCompilerErrorParameters parameters;
		if (parserErrorCode != TraceCompilerErrorCode.OK) {
			code = parserErrorCode;
			parameters = parserErrorParameters;
		} else if (converterErrorCode != TraceCompilerErrorCode.OK) {
			code = converterErrorCode;
			parameters = converterErrorParameters;
		} else {
			code = TraceCompilerErrorCode.TRACE_DOES_NOT_EXIST;
			parameters = null;
			if (parserRule != null) {
				code = parserRule.getLocationParser().checkLocationValidity(
						this);
			}
		}
		if (code != notifiedValidity) {
			notifiedValidity = code;
			notifiedValidityParameters = parameters;
			Iterator<SourceLocationListener> itr = getListeners();
			while (itr.hasNext()) {
				SourceLocationListener listener = itr.next();
				if (listener instanceof SourceLocationListener) {
					((SourceLocationListener) listener)
							.locationValidityChanged(this);
				}
			}
		}
	}

	/**
	 * Sets the converter error code and runs the validity check to notify
	 * listeners about change in error code
	 * 
	 * @param errorCode
	 *            the new error code
	 * @param parameters
	 *            the error parameters
	 */
	void setConverterErrorCode(TraceCompilerErrorCode errorCode,
			TraceCompilerErrorParameters parameters) {
		converterErrorCode = errorCode;
		converterErrorParameters = parameters;
		runValidityCheck();
	}

	/**
	 * Flag, which determines if the location has changed since last convert
	 * operation
	 * 
	 * @return the flag
	 */
	public boolean hasChangedAfterConvert() {
		return changedAfterConvert;
	}

	/**
	 * Called when the location has been converted. Sets the changed after
	 * convert flag to false
	 */
	public void locationConverted() {
		changedAfterConvert = false;
	}

}