/*
* Copyright (c) 2008 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:
*
* Parser for preprocessor definitions and include statements
*
*/
package com.nokia.tracebuilder.source;

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

/**
 * Parser for preprocessor definitions and include statements
 * 
 */
class PreprocessorDefinitionParser {

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

	/**
	 * List of #define's found from source
	 */
	protected ArrayList<SourcePreprocessorDefinition> preprocessorDefinitions;

	/**
	 * List of #include's found from source
	 */
	protected ArrayList<SourceInclude> includes;

	/**
	 * Constructor
	 * 
	 * @param parser
	 *            the source parser
	 */
	PreprocessorDefinitionParser(SourceParser parser) {
		this.parser = parser;
	}

	/**
	 * Resets all definitions parsed from the source
	 */
	void reset() {
		if (preprocessorDefinitions != null) {
			preprocessorDefinitions.clear();
		}
		if (includes != null) {
			includes.clear();
		}
	}

	/**
	 * Locates the value of a preprocessor definition for given name.
	 * 
	 * @param name
	 *            the name of the definition
	 * @return the value or null if not found
	 * @throws SourceParserException
	 *             if parser fails
	 */
	String findDefine(String name) throws SourceParserException {
		if (preprocessorDefinitions == null
				|| preprocessorDefinitions.isEmpty()) {
			createDefines();
		}
		Iterator<SourcePreprocessorDefinition> itr = preprocessorDefinitions
				.iterator();
		String retval = null;
		while (itr.hasNext() && retval == null) {
			SourcePreprocessorDefinition def = itr.next();
			if (def.getName().equals(name)) {
				retval = def.getValue();
			}
		}
		return retval;
	}

	/**
	 * Finds an include definition with given name
	 * 
	 * @param name
	 *            the include file name
	 * @return
	 *            <ul>
	 *            <li>if found, index to start of #include
	 *            <li>if not, -1 - index to end of last #include
	 *            </ul>
	 * @throws SourceParserException
	 *             if parser fails
	 */
	int findInclude(String name) throws SourceParserException {

		createIncludes();

		Iterator<SourceInclude> itr = includes.iterator();
		int ret = -1;
		while (itr.hasNext()) {
			SourceInclude inc = itr.next();
			if (inc.getHeaderName().equalsIgnoreCase(name)) {
				ret = inc.getOffset();
			}
		}
		if (ret == -1 && includes.size() > 0) {
			SourceInclude inc = includes.get(includes.size() - 1);
			ret = -1 - (inc.getOffset() + inc.getLength());
		}
		return ret;
	}

	/**
	 * Creates the list of preprocessor definitions. This only works with simple
	 * values
	 * 
	 * @throws SourceParserException
	 *             if parser fails
	 */
	private void createDefines() throws SourceParserException {
		if (preprocessorDefinitions == null) {
			preprocessorDefinitions = new ArrayList<SourcePreprocessorDefinition>();
		} else {
			preprocessorDefinitions.clear();
		}
		Iterator<SourceExcludedArea> excludedAreas = parser.getExcludedAreas()
				.iterator();
		while (excludedAreas.hasNext()) {
			createDefineFromExcludedArea(excludedAreas.next());
		}
	}

	/**
	 * Creates the list of include definitions
	 * 
	 * @throws SourceParserException
	 *             if parser fails
	 */
	private void createIncludes() throws SourceParserException {
		if (includes == null) {
			includes = new ArrayList<SourceInclude>();
		} else {
			includes.clear();
		}
		Iterator<SourceExcludedArea> excludedAreas = parser.getExcludedAreas()
				.iterator();
		while (excludedAreas.hasNext()) {
			createIncludeFromExcludedArea(excludedAreas.next());
		}
	}

	/**
	 * Creates an #define definition from given excluded area
	 * 
	 * @param area
	 *            the area
	 * @throws SourceParserException
	 */
	private void createDefineFromExcludedArea(SourceExcludedArea area)
			throws SourceParserException {
		if (area.getType() == SourceExcludedArea.PREPROCESSOR_DEFINITION
				&& area.getLength() > SourceConstants.DEFINE.length()) {
			String tag = parser.getSource().get(area.getOffset(),
					SourceConstants.DEFINE.length());
			if (tag.equals(SourceConstants.DEFINE)) {
				// Cannot use SKIP_ALL here, since it contains SKIP_PREPROCESSOR
				SourceIterator itr = parser.createIterator(area.getOffset()
						+ SourceConstants.DEFINE.length(),
						SourceParser.SKIP_WHITE_SPACES
								| SourceParser.SKIP_COMMENTS);
				if (itr.hasNext()) {
					parsePreprocessorDefinition(itr);
				}
			}
		}
	}

	/**
	 * Creates an #include definition from given excluded area
	 * 
	 * @param area
	 *            the area
	 * @throws SourceParserException
	 *             if parser fails
	 */
	private void createIncludeFromExcludedArea(SourceExcludedArea area)
			throws SourceParserException {
		if (area.getType() == SourceExcludedArea.PREPROCESSOR_DEFINITION
				&& area.getLength() > SourceConstants.INCLUDE.length()) {
			String tag = parser.getSource().get(area.getOffset(),
					SourceConstants.INCLUDE.length());
			if (tag.equals(SourceConstants.INCLUDE)) {
				// Cannot use SKIP_ALL here, since it contains SKIP_PREPROCESSOR
				SourceIterator itr = parser.createIterator(area.getOffset()
						+ SourceConstants.INCLUDE.length(),
						SourceParser.SKIP_WHITE_SPACES
								| SourceParser.SKIP_COMMENTS);
				if (itr.hasNext()) {
					parseInclude(itr);
				}
			}
		}
	}

	/**
	 * Parses a preprocessor definition. This only finds simple values
	 * 
	 * @param itr
	 *            source iterator, positioned so that next will return the first
	 *            character of the name of the definition
	 * @throws SourceParserException
	 *             if parser fails
	 */
	private void parsePreprocessorDefinition(SourceIterator itr)
			throws SourceParserException {
		int start = itr.nextIndex();
		int defstart = -1;
		SourcePreprocessorDefinition def = new SourcePreprocessorDefinition(
				parser, start);
		while (itr.hasNext() && def != null) {
			itr.next();
			if (itr.hasSkipped()) {
				if (defstart == -1) {
					if ((itr.previousIndex() + 1) > start) {
						def.setName(parser.getSource().get(start,
								itr.previousIndex() + 1 - start));
						defstart = itr.currentIndex();
					} else {
						def = null;
					}
				} else {
					def.setValue(parser.getSource().get(defstart,
							itr.previousIndex() + 1 - defstart));
					def.setLength(itr.previousIndex() + 1 - def.getOffset());
					preprocessorDefinitions.add(def);
					def = null;
				}
			}
		}
	}

	/**
	 * Parses an include line
	 * 
	 * @param itr
	 *            source iterator, positioned so that next will return the first
	 *            character of the name of the definition
	 * @throws SourceParserException
	 *             if parser fails
	 */
	private void parseInclude(SourceIterator itr) throws SourceParserException {
		int start = itr.nextIndex();
		SourceInclude inc = new SourceInclude(parser, start);
		while (itr.hasNext() && inc != null) {
			itr.next();
			if (itr.hasSkipped() && (itr.previousIndex()) > (start + 1)) {
				inc.setHeaderName(parser.getSource().get(start + 1,
						itr.previousIndex() - (start + 1)));
				inc.setLength(itr.previousIndex() - inc.getOffset() + 1);
				includes.add(inc);
				inc = null;
			}
		}
	}

}