/*******************************************************************************
 * Copyright (c) 2000, 2016 IBM Corporation and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 *******************************************************************************/
package org.eclipse.dltk.internal.core;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.dltk.compiler.CharOperation;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IBuildpathEntry;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IProjectFragment;
import org.eclipse.dltk.core.IScriptFolder;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.IType;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.environment.EnvironmentPathUtils;
import org.eclipse.dltk.internal.compiler.env.AccessRestriction;
import org.eclipse.dltk.internal.compiler.env.AccessRuleSet;
import org.eclipse.dltk.internal.core.util.HashtableOfArrayToObject;
import org.eclipse.dltk.internal.core.util.Messages;
import org.eclipse.dltk.internal.core.util.Util;

/**
 * A <code>NameLookup</code> provides name resolution within a Script project.
 * The name lookup facility uses the project's classpath to prioritize the order
 * in which package fragments are searched when resolving a name.
 * 
 * <p>
 * Name lookup only returns a handle when the named element actually exists in
 * the model; otherwise <code>null</code> is returned.
 * 
 * <p>
 * There are two logical sets of methods within this interface. Methods which
 * start with <code>find*</code> are intended to be convenience methods for
 * quickly finding an element within another element; for instance, for finding
 * a class within a package. The other set of methods all begin with
 * <code>seek*</code>. These methods do comprehensive searches of the
 * <code>IScriptProject</code> returning hits in real time through an
 * <code>IModelElementRequestor</code>.
 * 
 */
public class NameLookup {
	public static class Answer {
		public IType type;
		AccessRestriction restriction;

		Answer(IType type, AccessRestriction restriction) {
			this.type = type;
			this.restriction = restriction;
		}

		public boolean ignoreIfBetter() {
			return this.restriction != null
					&& this.restriction.ignoreIfBetter();
		}

		/*
		 * Returns whether this answer is better than the other awswer.
		 * (accessible is better than discouraged, which is better than
		 * non-accessible)
		 */
		public boolean isBetter(Answer otherAnswer) {
			if (otherAnswer == null)
				return true;
			if (this.restriction == null)
				return true;
			return otherAnswer.restriction != null
					&& this.restriction.getProblemId() < otherAnswer.restriction
							.getProblemId();
		}
	}

	/*
	 * Accept flag for all kinds of types
	 */

	public static boolean VERBOSE = DLTKCore.VERBOSE_SEARCH_NAMELOOKUP;

	private static final IType[] NO_TYPES = {};

	public static final int ACCEPT_ALL = 0;

	/**
	 * The <code>IScriptFolderRoot</code>'s associated with the buildpath of
	 * this NameLookup facility's project.
	 */
	protected IProjectFragment[] projectFragments;

	/**
	 * Table that maps package names to lists of package fragment roots that
	 * contain such a package known by this name lookup facility. To allow > 1
	 * package fragment with the same name, values are arrays of package
	 * fragment roots ordered as they appear on the buildpath. Note if the list
	 * is of size 1, then the IScriptFolderRoot object replaces the array.
	 */
	protected HashtableOfArrayToObject scriptFolders;

	/*
	 * A set of names (String[]) that are known to be package names. Value is
	 * not null for known package.
	 */
	protected HashtableOfArrayToObject isPackageCache;

	/**
	 * Reverse map from root path to corresponding resolved CP entry (so as to
	 * be able to figure inclusion/exclusion rules)
	 */
	protected Map rootToResolvedEntries;

	/**
	 * A map from package handles to a map from type name to an IType or an
	 * IType[]. Allows working copies to take precedence over compilation units.
	 */
	protected HashMap typesInWorkingCopies;

	public long timeSpentInSeekTypesInSourcePackage = 0;
	public long timeSpentInSeekTypesInBinaryPackage = 0;

	public NameLookup(IProjectFragment[] ProjectFragments,
			HashtableOfArrayToObject ScriptFolders,
			HashtableOfArrayToObject isPackage, ISourceModule[] workingCopies,
			Map rootToResolvedEntries) {
		long start = -1;
		if (VERBOSE) {
			Util.verbose(" BUILDING NameLoopkup"); //$NON-NLS-1$
			Util.verbose(" -> pkg roots size: " + (ProjectFragments == null ? 0 : ProjectFragments.length)); //$NON-NLS-1$
			Util.verbose(" -> pkgs size: " + (ScriptFolders == null ? 0 : ScriptFolders.size())); //$NON-NLS-1$
			Util.verbose(" -> working copy size: " + (workingCopies == null ? 0 : workingCopies.length)); //$NON-NLS-1$
			start = System.currentTimeMillis();
		}
		this.projectFragments = ProjectFragments;
		if (workingCopies == null) {
			this.scriptFolders = ScriptFolders;
			this.isPackageCache = isPackage;
		} else {
			// clone tables as we're adding packages from working copies
			try {
				this.scriptFolders = (HashtableOfArrayToObject) ScriptFolders
						.clone();
				this.isPackageCache = (HashtableOfArrayToObject) isPackage
						.clone();
			} catch (CloneNotSupportedException e1) {
				// ignore (implementation of HashtableOfArrayToObject supports
				// cloning)
			}
			this.typesInWorkingCopies = new HashMap();
			for (int i = 0, length = workingCopies.length; i < length; i++) {
				ISourceModule workingCopy = workingCopies[i];
				IScriptFolder pkg = (IScriptFolder) workingCopy.getParent();
				HashMap typeMap = (HashMap) this.typesInWorkingCopies.get(pkg);
				if (typeMap == null) {
					typeMap = new HashMap();
					this.typesInWorkingCopies.put(pkg, typeMap);
				}
				try {
					IType[] types = workingCopy.getTypes();
					int typeLength = types.length;
					if (typeLength == 0) {
						String typeName = workingCopy.getElementName();
						typeMap.put(typeName, NO_TYPES);
					} else {
						for (int j = 0; j < typeLength; j++) {
							IType type = types[j];
							String typeName = type.getElementName();
							Object existing = typeMap.get(typeName);
							if (existing == null) {
								typeMap.put(typeName, type);
							} else if (existing instanceof IType) {
								typeMap.put(typeName, new IType[] {
										(IType) existing, type });
							} else {
								IType[] existingTypes = (IType[]) existing;
								int existingTypeLength = existingTypes.length;
								System.arraycopy(
										existingTypes,
										0,
										existingTypes = new IType[existingTypeLength + 1],
										0, existingTypeLength);
								existingTypes[existingTypeLength] = type;
								typeMap.put(typeName, existingTypes);
							}
						}
					}
				} catch (ModelException e) {
					// working copy doesn't exist -> ignore
				}

				// add root of package fragment to cache
				IProjectFragment root = (IProjectFragment) pkg.getParent();
				IPath pkgPath = pkg.getPath().removeFirstSegments(
						root.getPath().segmentCount());
				String[] pkgName = pkgPath.segments();
				Object existing = this.scriptFolders.get(pkgName);
				if (existing == null) {
					this.scriptFolders.put(pkgName, root);
					// cache whether each package and its including packages
					// (see
					// https://bugs.eclipse.org/bugs/show_bug.cgi?id=119161)
					// are actual packages
					ProjectElementInfo.addNames(pkgName, this.isPackageCache);
				} else {
					if (existing instanceof IProjectFragment) {
						if (!existing.equals(root))
							this.scriptFolders
									.put(pkgName, new IProjectFragment[] {
											(IProjectFragment) existing, root });
					} else {
						IProjectFragment[] roots = (IProjectFragment[]) existing;
						int rootLength = roots.length;
						boolean containsRoot = false;
						for (int j = 0; j < rootLength; j++) {
							if (roots[j].equals(root)) {
								containsRoot = true;
								break;
							}
						}
						if (containsRoot) {
							System.arraycopy(
									roots,
									0,
									roots = new IProjectFragment[rootLength + 1],
									0, rootLength);
							roots[rootLength] = root;
							this.scriptFolders.put(pkgName, roots);
						}
					}
				}
			}
		}

		this.rootToResolvedEntries = rootToResolvedEntries;
		if (VERBOSE) {
			Util.verbose(" -> spent: " + (System.currentTimeMillis() - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}

	/**
	 * Returns true if:
	 * <ul>
	 * <li>the given type is an existing class and the flag's
	 * <code>ACCEPT_CLASSES</code> bit is on
	 * <li>the given type is an existing interface and the
	 * <code>ACCEPT_INTERFACES</code> bit is on
	 * <li>neither the <code>ACCEPT_CLASSES</code> or
	 * <code>ACCEPT_INTERFACES</code> bit is on
	 * </ul>
	 * Otherwise, false is returned.
	 */
	protected boolean acceptType(IType type, int acceptFlags,
			boolean isSourceType) {
		return true;
	}

	/**
	 * Finds every type in the project whose simple name matches the prefix,
	 * informing the requestor of each hit. The requestor is polled for
	 * cancellation at regular intervals.
	 * 
	 * <p>
	 * The <code>partialMatch</code> argument indicates partial matches should
	 * be considered.
	 */
	private void findAllTypes(String prefix, boolean partialMatch,
			int acceptFlags, IModelElementRequestor requestor) {
		int count = this.projectFragments.length;
		for (int i = 0; i < count; i++) {
			if (requestor.isCanceled())
				return;
			IProjectFragment root = this.projectFragments[i];
			IModelElement[] packages = null;
			try {
				packages = root.getChildren();
			} catch (ModelException npe) {
				continue; // the root is not present, continue;
			}
			if (packages != null) {
				for (int j = 0, packageCount = packages.length; j < packageCount; j++) {
					if (requestor.isCanceled())
						return;
					seekTypes(prefix, (IScriptFolder) packages[j],
							partialMatch, acceptFlags, requestor);
				}
			}
		}
	}

	/**
	 * Returns the <code>ISourceModule</code> which defines the type named
	 * <code>qualifiedTypeName</code>, or <code>null</code> if none exists. The
	 * domain of the search is bounded by the classpath of the
	 * <code>IScriptProject</code> this <code>NameLookup</code> was obtained
	 * from.
	 * <p>
	 * The name must be fully qualified (eg "java.lang.Object",
	 * "java.util.Hashtable$Entry")
	 */
	public ISourceModule findSourceModule(String qualifiedTypeName) {
		String[] pkgName = CharOperation.NO_STRINGS;
		String cuName = qualifiedTypeName;

		int index = qualifiedTypeName.lastIndexOf('.');
		if (index != -1) {
			pkgName = Util.splitOn('.', qualifiedTypeName, 0, index);
			cuName = qualifiedTypeName.substring(index + 1);
		}
		index = cuName.indexOf('$');
		if (index != -1) {
			cuName = cuName.substring(0, index);
		}
		Object value = this.scriptFolders.get(pkgName);
		if (value != null) {
			if (value instanceof IProjectFragment) {
				return findSourceModule(pkgName, cuName,
						(IProjectFragment) value);
			} else {
				IProjectFragment[] roots = (IProjectFragment[]) value;
				for (int i = 0; i < roots.length; i++) {
					IProjectFragment root = roots[i];
					ISourceModule cu = findSourceModule(pkgName, cuName, root);
					if (cu != null)
						return cu;
				}
			}
		}
		return null;
	}

	private IPath toPath(String pkgName[]) {
		IPath path = new Path(""); //$NON-NLS-1$
		for (int i = 0; i < pkgName.length; ++i) {
			path = path.append(pkgName[i]);
		}
		return path;
	}

	private ISourceModule findSourceModule(String[] pkgName, String cuName,
			IProjectFragment root) {
		if (!root.isArchive()) {
			IScriptFolder pkg = root.getScriptFolder(toPath(pkgName));
			try {
				ISourceModule[] cus = pkg.getSourceModules();
				for (int j = 0, length = cus.length; j < length; j++) {
					ISourceModule cu = cus[j];
					if (Util.equalsIgnoreExtension(cu.getElementName(), cuName))
						return cu;
				}
			} catch (ModelException e) {
				// pkg does not exist
				// -> try next package
			}
		}
		return null;
	}

	private static boolean equals(String s1, String s2) {
		return s1 == null ? s2 == null : s1.equals(s2);
	}

	/**
	 * Returns the package fragment whose path matches the given (absolute)
	 * path, or <code>null</code> if none exist. The domain of the search is
	 * bounded by the buildpath of the <code>IScriptProject</code> this
	 * <code>NameLookup</code> was obtained from. The path can be: - internal to
	 * the workbench: "/Project/src" - external to the workbench:
	 * "c:/jdk/classes.zip/java/lang"
	 */
	public IScriptFolder findScriptFolder(IPath path) {
		if (!path.isAbsolute()) {
			throw new IllegalArgumentException(Messages.path_mustBeAbsolute);
		}
		/*
		 * TODO (jerome) this code should rather use the package fragment map to
		 * find the candidate package, then check if the respective enclosing
		 * root maps to the one on this given IPath.
		 */
		IResource possibleFragment = ResourcesPlugin.getWorkspace().getRoot()
				.findMember(path);
		if (possibleFragment == null) {
			// external jar
			final boolean isFullPath = EnvironmentPathUtils.isFull(path);
			for (int i = 0; i < this.projectFragments.length; i++) {
				IProjectFragment root = this.projectFragments[i];
				if (!root.isExternal() || root.isBuiltin()) {
					continue;
				}
				IPath rootPath = root.getPath();
				if (!isFullPath) {
					rootPath = EnvironmentPathUtils.getLocalPath(rootPath);
				}
				int matchingCount = rootPath.matchingFirstSegments(path);
				if (matchingCount != 0
						&& equals(rootPath.getDevice(), path.getDevice())) {
					final String name = path.removeFirstSegments(matchingCount)
							.setDevice(null).makeRelative().toString();
					IModelElement[] list = null;
					try {
						list = root.getChildren();
					} catch (ModelException npe) {
						continue; // the package fragment root is not present;
					}
					int elementCount = list.length;
					for (int j = 0; j < elementCount; j++) {
						IScriptFolder scriptFolder = (IScriptFolder) list[j];
						if (nameMatches(name, scriptFolder, false)) {
							return scriptFolder;
						}
					}
				}
			}
		} else {
			IModelElement fromFactory = DLTKCore.create(possibleFragment);
			if (fromFactory == null) {
				return null;
			}
			switch (fromFactory.getElementType()) {
			case IModelElement.SCRIPT_FOLDER:
				return (IScriptFolder) fromFactory;
			case IModelElement.SCRIPT_PROJECT:
				// default package in a default root
				ScriptProject project = (ScriptProject) fromFactory;
				try {
					IBuildpathEntry entry = project.getBuildpathEntryFor(path);
					if (entry != null) {
						IProjectFragment root = project
								.getProjectFragment(project.getResource());
						Object defaultPkgRoot = this.scriptFolders
								.get(CharOperation.NO_STRINGS);
						if (defaultPkgRoot == null) {
							return null;
						}
						if (defaultPkgRoot instanceof IProjectFragment
								&& defaultPkgRoot.equals(root))
							return root.getScriptFolder(Path.EMPTY);
						else {
							IProjectFragment[] roots = (IProjectFragment[]) defaultPkgRoot;
							for (int i = 0; i < roots.length; i++) {
								if (roots[i].equals(root)) {
									return root.getScriptFolder(Path.EMPTY);
								}
							}
						}
					}
				} catch (ModelException e) {
					return null;
				}
				return null;
			case IModelElement.PROJECT_FRAGMENT:
				return ((IProjectFragment) fromFactory)
						.getScriptFolder(Path.EMPTY);
			}
		}
		return null;
	}

	/**
	 * Returns the package fragments whose name matches the given (qualified)
	 * name, or <code>null</code> if none exist.
	 * 
	 * The name can be: - empty: "" - qualified: "pack.pack1.pack2"
	 * 
	 * @param partialMatch
	 *            partial name matches qualify when <code>true</code>, only
	 *            exact name matches qualify when <code>false</code>
	 */
	public IScriptFolder[] findScriptFolders(String name, boolean partialMatch) {
		if (partialMatch) {
			String[] splittedName = Util.splitOn('.', name, 0, name.length());
			IScriptFolder[] oneFragment = null;
			ArrayList pkgs = null;
			Object[][] keys = this.scriptFolders.keyTable;
			for (int i = 0, length = keys.length; i < length; i++) {
				String[] pkgName = (String[]) keys[i];
				if (pkgName != null
						&& Util.startsWithIgnoreCase(pkgName, splittedName)) {
					Object value = this.scriptFolders.valueTable[i];
					if (value instanceof IProjectFragment) {
						IScriptFolder pkg = ((IProjectFragment) value)
								.getScriptFolder(toPath(pkgName));
						if (oneFragment == null) {
							oneFragment = new IScriptFolder[] { pkg };
						} else {
							if (pkgs == null) {
								pkgs = new ArrayList();
								pkgs.add(oneFragment[0]);
							}
							pkgs.add(pkg);
						}
					} else {
						IProjectFragment[] roots = (IProjectFragment[]) value;
						for (int j = 0, length2 = roots.length; j < length2; j++) {
							IProjectFragment root = roots[j];
							IScriptFolder pkg = root
									.getScriptFolder(toPath(pkgName));
							if (oneFragment == null) {
								oneFragment = new IScriptFolder[] { pkg };
							} else {
								if (pkgs == null) {
									pkgs = new ArrayList();
									pkgs.add(oneFragment[0]);
								}
								pkgs.add(pkg);
							}
						}
					}
				}
			}
			if (pkgs == null)
				return oneFragment;
			int resultLength = pkgs.size();
			IScriptFolder[] result = new IScriptFolder[resultLength];
			pkgs.toArray(result);
			return result;
		} else {
			String[] splittedName = Util.splitOn('.', name, 0, name.length());
			Object value = this.scriptFolders.get(splittedName);
			if (value == null)
				return null;
			if (value instanceof IProjectFragment) {
				return new IScriptFolder[] { ((IProjectFragment) value)
						.getScriptFolder(toPath(splittedName)) };
			} else {
				IProjectFragment[] roots = (IProjectFragment[]) value;
				IScriptFolder[] result = new IScriptFolder[roots.length];
				for (int i = 0; i < roots.length; i++) {
					result[i] = roots[i].getScriptFolder(toPath(splittedName));
				}
				return result;
			}
		}
	}

	/**
	 * Find type considering secondary types but without waiting for indexes. It
	 * means that secondary types may be not found under certain
	 * circumstances...
	 * 
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=118789"
	 */
	public Answer findType(String typeName, String packageName,
			boolean partialMatch, int acceptFlags, boolean checkRestrictions) {
		return findType(typeName, packageName, partialMatch, acceptFlags,
				true/* consider secondary types */, false/*
														 * do NOT wait for
														 * indexes
														 */, checkRestrictions,
				null);
	}

	/**
	 * Find type. Considering secondary types and waiting for indexes depends on
	 * given corresponding parameters.
	 */
	public Answer findType(String typeName, String packageName,
			boolean partialMatch, int acceptFlags,
			boolean considerSecondaryTypes, boolean waitForIndexes,
			boolean checkRestrictions, IProgressMonitor monitor) {
		if (packageName == null || packageName.length() == 0) {
			packageName = IScriptFolder.DEFAULT_FOLDER_NAME;
		} else if (typeName.length() > 0
				&& Character.isLowerCase(typeName.charAt(0))) {
			// see if this is a known package and not a type
			if (findScriptFolders(packageName + "." + typeName, false) != null)return null; //$NON-NLS-1$
		}

		// Look for concerned package fragments
		ModelElementRequestor elementRequestor = new ModelElementRequestor();
		seekScriptFolders(packageName, false, elementRequestor);
		IScriptFolder[] packages = elementRequestor.getScriptFolders();

		// Try to find type in package fragments list
		IType type = null;
		int length = packages.length;
		HashSet projects = null;
		IScriptProject scriptProject = null;
		Answer suggestedAnswer = null;
		for (int i = 0; i < length; i++) {
			type = findType(typeName, packages[i], partialMatch, acceptFlags);
			if (type != null) {
				AccessRestriction accessRestriction = null;
				if (checkRestrictions) {
					accessRestriction = getViolatedRestriction(typeName,
							packageName, type, accessRestriction);
				}
				Answer answer = new Answer(type, accessRestriction);
				if (!answer.ignoreIfBetter()) {
					if (answer.isBetter(suggestedAnswer))
						return answer;
				} else if (answer.isBetter(suggestedAnswer))
					// remember suggestion and keep looking
					suggestedAnswer = answer;
			} else if (suggestedAnswer == null && considerSecondaryTypes) {
				if (scriptProject == null) {
					scriptProject = packages[i].getScriptProject();
				} else if (projects == null) {
					if (!scriptProject.equals(packages[i].getScriptProject())) {
						projects = new HashSet(3);
						projects.add(scriptProject);
						projects.add(packages[i].getScriptProject());
					}
				} else {
					projects.add(packages[i].getScriptProject());
				}
			}
		}
		if (suggestedAnswer != null)
			// no better answer was found
			return suggestedAnswer;

		return type == null ? null : new Answer(type, null);
	}

	private AccessRestriction getViolatedRestriction(String typeName,
			String packageName, IType type, AccessRestriction accessRestriction) {
		IProjectFragment root = (IProjectFragment) type
				.getAncestor(IModelElement.PROJECT_FRAGMENT);
		BuildpathEntry entry = (BuildpathEntry) this.rootToResolvedEntries
				.get(root);
		if (entry != null) { // reverse map always contains resolved CP entry
			AccessRuleSet accessRuleSet = entry.getAccessRuleSet();
			if (accessRuleSet != null) {
				// TODO (philippe) improve char[] <-> String conversions to
				// avoid performing them on the fly
				char[][] packageChars = CharOperation.splitOn('.',
						packageName.toCharArray());
				char[] typeChars = typeName.toCharArray();
				accessRestriction = accessRuleSet
						.getViolatedRestriction(CharOperation.concatWith(
								packageChars, typeChars, '/'));
			}
		}
		return accessRestriction;
	}

	/**
	 * Returns the first type in the given package whose name matches the given
	 * (unqualified) name, or <code>null</code> if none exist. Specifying a
	 * <code>null</code> package will result in no matches. The domain of the
	 * search is bounded by the Script project from which this name lookup was
	 * obtained.
	 * 
	 * @param name
	 *            the name of the type to find
	 * @param pkg
	 *            the package to search
	 * @param partialMatch
	 *            partial name matches qualify when <code>true</code>, only
	 *            exact name matches qualify when <code>false</code>
	 * @param acceptFlags
	 *            a bit mask describing if classes, interfaces or both classes
	 *            and interfaces are desired results. If no flags are specified,
	 *            all types are returned.
	 * @param considerSecondaryTypes
	 *            flag to know whether secondary types has to be considered
	 *            during the search
	 * 
	 * @see #ACCEPT_CLASSES
	 * @see #ACCEPT_INTERFACES
	 * @see #ACCEPT_ENUMS
	 * @see #ACCEPT_ANNOTATIONS
	 */
	public IType findType(String name, IScriptFolder pkg, boolean partialMatch,
			int acceptFlags, boolean considerSecondaryTypes) {
		IType type = findType(name, pkg, partialMatch, acceptFlags);
		return type;
	}

	/**
	 * Returns the first type in the given package whose name matches the given
	 * (unqualified) name, or <code>null</code> if none exist. Specifying a
	 * <code>null</code> package will result in no matches. The domain of the
	 * search is bounded by the Script project from which this name lookup was
	 * obtained. <br>
	 * Note that this method does not find secondary types. <br>
	 * 
	 * @param name
	 *            the name of the type to find
	 * @param pkg
	 *            the package to search
	 * @param partialMatch
	 *            partial name matches qualify when <code>true</code>, only
	 *            exact name matches qualify when <code>false</code>
	 * @param acceptFlags
	 *            a bit mask describing if classes, interfaces or both classes
	 *            and interfaces are desired results. If no flags are specified,
	 *            all types are returned.
	 * 
	 * @see #ACCEPT_CLASSES
	 * @see #ACCEPT_INTERFACES
	 * @see #ACCEPT_ENUMS
	 * @see #ACCEPT_ANNOTATIONS
	 */
	public IType findType(String name, IScriptFolder pkg, boolean partialMatch,
			int acceptFlags) {
		if (pkg == null)
			return null;

		// Return first found (ignore duplicates).
		SingleTypeRequestor typeRequestor = new SingleTypeRequestor();
		seekTypes(name, pkg, partialMatch, acceptFlags, typeRequestor);
		return typeRequestor.getType();
	}

	/**
	 * Returns the type specified by the qualified name, or <code>null</code> if
	 * none exist. The domain of the search is bounded by the Script project
	 * from which this name lookup was obtained.
	 * 
	 * @param name
	 *            the name of the type to find
	 * @param partialMatch
	 *            partial name matches qualify when <code>true</code>, only
	 *            exact name matches qualify when <code>false</code>
	 * @param acceptFlags
	 *            a bit mask describing if classes, interfaces or both classes
	 *            and interfaces are desired results. If no flags are specified,
	 *            all types are returned.
	 * 
	 * @see #ACCEPT_CLASSES
	 * @see #ACCEPT_INTERFACES
	 * @see #ACCEPT_ENUMS
	 * @see #ACCEPT_ANNOTATIONS
	 */
	public IType findType(String name, boolean partialMatch, int acceptFlags) {
		NameLookup.Answer answer = findType(name, partialMatch, acceptFlags,
				false/* don't check restrictions */);
		return answer == null ? null : answer.type;
	}

	public Answer findType(String name, boolean partialMatch, int acceptFlags,
			boolean checkRestrictions) {
		return findType(name, partialMatch, acceptFlags, true/*
															 * consider
															 * secondary types
															 */, true/*
																	 * wait for
																	 * indexes
																	 */,
				checkRestrictions, null);
	}

	public Answer findType(String name, boolean partialMatch, int acceptFlags,
			boolean considerSecondaryTypes, boolean waitForIndexes,
			boolean checkRestrictions, IProgressMonitor monitor) {
		int index = name.lastIndexOf('.');
		String className = null, packageName = null;
		if (index == -1) {
			packageName = IScriptFolder.DEFAULT_FOLDER_NAME;
			className = name;
		} else {
			packageName = name.substring(0, index);
			className = name.substring(index + 1);
		}
		return findType(className, packageName, partialMatch, acceptFlags,
				considerSecondaryTypes, waitForIndexes, checkRestrictions,
				monitor);
	}

	private IType getMemberType(IType type, String name, int dot) {
		while (dot != -1) {
			int start = dot + 1;
			dot = name.indexOf('.', start);
			String typeName = name.substring(start, dot == -1 ? name.length()
					: dot);
			type = type.getType(typeName);
		}
		return type;
	}

	public boolean isPackage(String[] pkgName) {
		return this.isPackageCache.get(pkgName) != null;
	}

	/**
	 * Returns true if the given element's name matches the specified
	 * <code>searchName</code>, otherwise false.
	 * 
	 * <p>
	 * The <code>partialMatch</code> argument indicates partial matches should
	 * be considered. NOTE: in partialMatch mode, the case will be ignored, and
	 * the searchName must already have been lowercased.
	 */
	protected boolean nameMatches(String searchName, IModelElement element,
			boolean partialMatch) {
		if (partialMatch) {
			// partial matches are used in completion mode, thus case
			// insensitive mode
			return element.getElementName().toLowerCase()
					.startsWith(searchName);
		} else {
			return element.getElementName().equals(searchName);
		}
	}

	/**
	 * Returns true if the given cu's name matches the specified
	 * <code>searchName</code>, otherwise false.
	 * 
	 * <p>
	 * The <code>partialMatch</code> argument indicates partial matches should
	 * be considered. NOTE: in partialMatch mode, the case will be ignored, and
	 * the searchName must already have been lowercased.
	 */
	protected boolean nameMatches(String searchName, ISourceModule cu,
			boolean partialMatch) {
		if (partialMatch) {
			// partial matches are used in completion mode, thus case
			// insensitive mode
			return cu.getElementName().toLowerCase().startsWith(searchName);
		} else {
			return Util.equalsIgnoreExtension(cu.getElementName(), searchName);
		}
	}

	/**
	 * Notifies the given requestor of all package fragments with the given
	 * name. Checks the requestor at regular intervals to see if the requestor
	 * has canceled. The domain of the search is bounded by the
	 * <code>IScriptProject</code> this <code>NameLookup</code> was obtained
	 * from.
	 * 
	 * @param partialMatch
	 *            partial name matches qualify when <code>true</code>; only
	 *            exact name matches qualify when <code>false</code>
	 */
	public void seekScriptFolders(String name, boolean partialMatch,
			IModelElementRequestor requestor) {
		/*
		 * if (VERBOSE) { Util.verbose(" SEEKING PACKAGE FRAGMENTS");
		 * //$NON-NLS-1$ Util.verbose(" -> name: " + name); //$NON-NLS-1$
		 * Util.verbose(" -> partial match:" + partialMatch); //$NON-NLS-1$ }
		 */if (partialMatch) {
			String[] splittedName = Util.splitOn('.', name, 0, name.length());
			Object[][] keys = this.scriptFolders.keyTable;
			for (int i = 0, length = keys.length; i < length; i++) {
				if (requestor.isCanceled())
					return;
				String[] pkgName = (String[]) keys[i];
				if (pkgName != null
						&& Util.startsWithIgnoreCase(pkgName, splittedName)) {
					Object value = this.scriptFolders.valueTable[i];
					if (value instanceof IProjectFragment) {
						IProjectFragment root = (IProjectFragment) value;
						requestor.acceptScriptFolder(root
								.getScriptFolder(toPath(pkgName)));
					} else {
						IProjectFragment[] roots = (IProjectFragment[]) value;
						for (int j = 0, length2 = roots.length; j < length2; j++) {
							if (requestor.isCanceled())
								return;
							IProjectFragment root = roots[j];
							requestor.acceptScriptFolder(root
									.getScriptFolder(toPath(pkgName)));
						}
					}
				}
			}
		} else {
			String[] splittedName = Util.splitOn('.', name, 0, name.length());
			Object value = this.scriptFolders.get(splittedName);
			if (value instanceof IProjectFragment) {
				requestor.acceptScriptFolder(((IProjectFragment) value)
						.getScriptFolder(toPath(splittedName)));
			} else {
				IProjectFragment[] roots = (IProjectFragment[]) value;
				if (roots != null) {
					for (int i = 0, length = roots.length; i < length; i++) {
						if (requestor.isCanceled())
							return;
						IProjectFragment root = roots[i];
						requestor.acceptScriptFolder(root
								.getScriptFolder(toPath(splittedName)));
					}
				}
			}
		}
	}

	/**
	 * Notifies the given requestor of all types (classes and interfaces) in the
	 * given package fragment with the given (unqualified) name. Checks the
	 * requestor at regular intervals to see if the requestor has canceled. If
	 * the given package fragment is <code>null</code>, all types in the project
	 * whose simple name matches the given name are found.
	 * 
	 * @param name
	 *            The name to search
	 * @param pkg
	 *            The corresponding package fragment
	 * @param partialMatch
	 *            partial name matches qualify when <code>true</code>; only
	 *            exact name matches qualify when <code>false</code>
	 * @param acceptFlags
	 *            a bit mask describing if classes, interfaces or both classes
	 *            and interfaces are desired results. If no flags are specified,
	 *            all types are returned.
	 * @param requestor
	 *            The requestor that collects the result
	 * 
	 * @see #ACCEPT_CLASSES
	 * @see #ACCEPT_INTERFACES
	 * @see #ACCEPT_ENUMS
	 * @see #ACCEPT_ANNOTATIONS
	 */
	public void seekTypes(String name, IScriptFolder pkg, boolean partialMatch,
			int acceptFlags, IModelElementRequestor requestor) {
		/*
		 * if (VERBOSE) { Util.verbose(" SEEKING TYPES"); //$NON-NLS-1$
		 * Util.verbose(" -> name: " + name); //$NON-NLS-1$
		 * Util.verbose(" -> pkg: " + ((ModelElement)
		 * pkg).toStringWithAncestors()); //$NON-NLS-1$
		 * Util.verbose(" -> partial match:" + partialMatch); //$NON-NLS-1$ }
		 */
		String matchName = partialMatch ? name.toLowerCase() : name;
		if (pkg == null) {
			findAllTypes(matchName, partialMatch, acceptFlags, requestor);
			return;
		}
		IProjectFragment root = (IProjectFragment) pkg.getParent();
		try {

			// look in working copies first
			int firstDot = -1;
			String topLevelTypeName = null;
			int packageFlavor = root.getKind();
			if (this.typesInWorkingCopies != null
					|| packageFlavor == IProjectFragment.K_SOURCE) {
				firstDot = matchName.indexOf('.');
				if (!partialMatch)
					topLevelTypeName = firstDot == -1 ? matchName : matchName
							.substring(0, firstDot);
			}
			if (this.typesInWorkingCopies != null) {
				if (seekTypesInWorkingCopies(matchName, pkg, firstDot,
						partialMatch, topLevelTypeName, acceptFlags, requestor))
					return;
			}

			// look in model
			switch (packageFlavor) {
			case IProjectFragment.K_SOURCE:
				seekTypesInSourcePackage(matchName, pkg, firstDot,
						partialMatch, topLevelTypeName, acceptFlags, requestor);
				break;
			default:
				return;
			}
		} catch (ModelException e) {
			return;
		}
	}

	/**
	 * Performs type search in a source package.
	 */
	protected void seekTypesInSourcePackage(String name, IScriptFolder pkg,
			int firstDot, boolean partialMatch, String topLevelTypeName,
			int acceptFlags, IModelElementRequestor requestor) {

		long start = -1;
		if (VERBOSE)
			start = System.currentTimeMillis();
		try {
			if (!partialMatch) {
				try {
					IModelElement[] compilationUnits = pkg.getChildren();
					for (int i = 0, length = compilationUnits.length; i < length; i++) {
						if (requestor.isCanceled())
							return;
						IModelElement cu = compilationUnits[i];
						String cuName = cu.getElementName();
						int lastDot = cuName.lastIndexOf('.');
						if (lastDot != topLevelTypeName.length()
								|| !topLevelTypeName.regionMatches(0, cuName,
										0, lastDot))
							continue;
						IType type = ((ISourceModule) cu)
								.getType(topLevelTypeName);
						type = getMemberType(type, name, firstDot);
						if (acceptType(type, acceptFlags, true/* a source type */)) { // accept
							// type
							// checks
							// for
							// existence
							requestor.acceptType(type);
							break; // since an exact match was requested, no
							// other matching type can exist
						}
					}
				} catch (ModelException e) {
					// package doesn't exist -> ignore
				}
			} else {
				try {
					String cuPrefix = firstDot == -1 ? name : name.substring(0,
							firstDot);
					IModelElement[] compilationUnits = pkg.getChildren();
					for (int i = 0, length = compilationUnits.length; i < length; i++) {
						if (requestor.isCanceled())
							return;
						IModelElement cu = compilationUnits[i];
						if (!cu.getElementName().toLowerCase()
								.startsWith(cuPrefix))
							continue;
						try {
							IType[] types = ((ISourceModule) cu).getTypes();
							for (int j = 0, typeLength = types.length; j < typeLength; j++)
								seekTypesInTopLevelType(name, firstDot,
										types[j], requestor, acceptFlags);
						} catch (ModelException e) {
							// cu doesn't exist -> ignore
						}
					}
				} catch (ModelException e) {
					// package doesn't exist -> ignore
				}
			}
		} finally {
			if (VERBOSE)
				this.timeSpentInSeekTypesInSourcePackage += System
						.currentTimeMillis() - start;
		}
	}

	/**
	 * Notifies the given requestor of all types (classes and interfaces) in the
	 * given type with the given (possibly qualified) name. Checks the requestor
	 * at regular intervals to see if the requestor has canceled.
	 */
	protected boolean seekTypesInType(String prefix, int firstDot, IType type,
			IModelElementRequestor requestor, int acceptFlags) {
		IType[] types = null;
		try {
			types = type.getTypes();
		} catch (ModelException npe) {
			return false; // the enclosing type is not present
		}
		int length = types.length;
		if (length == 0)
			return false;

		String memberPrefix = prefix;
		boolean isMemberTypePrefix = false;
		if (firstDot != -1) {
			memberPrefix = prefix.substring(0, firstDot);
			isMemberTypePrefix = true;
		}
		for (int i = 0; i < length; i++) {
			if (requestor.isCanceled())
				return false;
			IType memberType = types[i];
			if (memberType.getElementName().toLowerCase()
					.startsWith(memberPrefix))
				if (isMemberTypePrefix) {
					String subPrefix = prefix.substring(firstDot + 1,
							prefix.length());
					return seekTypesInType(subPrefix, subPrefix.indexOf('.'),
							memberType, requestor, acceptFlags);
				} else {
					if (acceptType(memberType, acceptFlags, true/* a source type */)) {
						requestor.acceptMemberType(memberType);
						return true;
					}
				}
		}
		return false;
	}

	protected boolean seekTypesInTopLevelType(String prefix, int firstDot,
			IType topLevelType, IModelElementRequestor requestor,
			int acceptFlags) {
		if (!topLevelType.getElementName().toLowerCase().startsWith(prefix))
			return false;
		if (firstDot == -1) {
			if (acceptType(topLevelType, acceptFlags, true/* a source type */)) {
				requestor.acceptType(topLevelType);
				return true;
			}
		} else {
			return seekTypesInType(prefix, firstDot, topLevelType, requestor,
					acceptFlags);
		}
		return false;
	}

	/*
	 * Seeks the type with the given name in the map of types with precedence
	 * (coming from working copies) Return whether a type has been found.
	 */
	protected boolean seekTypesInWorkingCopies(String name, IScriptFolder pkg,
			int firstDot, boolean partialMatch, String topLevelTypeName,
			int acceptFlags, IModelElementRequestor requestor) {

		if (!partialMatch) {
			HashMap typeMap = (HashMap) (this.typesInWorkingCopies == null ? null
					: this.typesInWorkingCopies.get(pkg));
			if (typeMap != null) {
				Object object = typeMap.get(topLevelTypeName);
				if (object instanceof IType) {
					IType type = getMemberType((IType) object, name, firstDot);
					if (acceptType(type, acceptFlags, true/* a source type */)) {
						requestor.acceptType(type);
						return true; // don't continue with compilation unit
					}
				} else if (object instanceof IType[]) {
					if (object == NO_TYPES)
						return true; // all types where deleted -> type is
					// hidden
					IType[] topLevelTypes = (IType[]) object;
					for (int i = 0, length = topLevelTypes.length; i < length; i++) {
						if (requestor.isCanceled())
							return false;
						IType type = getMemberType(topLevelTypes[i], name,
								firstDot);
						if (acceptType(type, acceptFlags, true/* a source type */)) {
							requestor.acceptType(type);
							return true; // return the first one
						}
					}
				}
			}
		} else {
			HashMap typeMap = (HashMap) (this.typesInWorkingCopies == null ? null
					: this.typesInWorkingCopies.get(pkg));
			if (typeMap != null) {
				Iterator iterator = typeMap.values().iterator();
				while (iterator.hasNext()) {
					if (requestor.isCanceled())
						return false;
					Object object = iterator.next();
					if (object instanceof IType) {
						seekTypesInTopLevelType(name, firstDot, (IType) object,
								requestor, acceptFlags);
					} else if (object instanceof IType[]) {
						IType[] topLevelTypes = (IType[]) object;
						for (int i = 0, length = topLevelTypes.length; i < length; i++)
							seekTypesInTopLevelType(name, firstDot,
									topLevelTypes[i], requestor, acceptFlags);
					}
				}
			}
		}
		return false;
	}

}