/*******************************************************************************
 * 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
 *
 * Contributors:
 *     xored software, Inc. - initial API and Implementation
 *     xored software, Inc. - Search All occurences bugfix, 
 *     						  hilight only class name when class is in search results ( Alex Panchenko <alex@xored.com>)
 *******************************************************************************/
package org.eclipse.dltk.core.search.matching;

import java.text.Annotation;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.declarations.FieldDeclaration;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.declarations.TypeDeclaration;
import org.eclipse.dltk.ast.expressions.CallExpression;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.references.Reference;
import org.eclipse.dltk.ast.references.TypeReference;
import org.eclipse.dltk.compiler.CharOperation;
import org.eclipse.dltk.compiler.env.lookup.Scope;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.search.SearchMatch;
import org.eclipse.dltk.core.search.SearchPattern;
import org.eclipse.dltk.core.search.indexing.IIndexConstants;
import org.eclipse.dltk.internal.core.search.matching.DLTKSearchPattern;
import org.eclipse.dltk.internal.core.search.matching.FieldLocator;
import org.eclipse.dltk.internal.core.search.matching.FieldPattern;
import org.eclipse.dltk.internal.core.search.matching.InternalSearchPattern;
import org.eclipse.dltk.internal.core.search.matching.MatchingNodeSet;
import org.eclipse.dltk.internal.core.search.matching.MethodDeclarationLocator;
import org.eclipse.dltk.internal.core.search.matching.MethodDeclarationPattern;
import org.eclipse.dltk.internal.core.search.matching.MethodLocator;
import org.eclipse.dltk.internal.core.search.matching.MethodPattern;
import org.eclipse.dltk.internal.core.search.matching.OrLocator;
import org.eclipse.dltk.internal.core.search.matching.OrPattern;
import org.eclipse.dltk.internal.core.search.matching.TypeDeclarationLocator;
import org.eclipse.dltk.internal.core.search.matching.TypeDeclarationPattern;
import org.eclipse.dltk.internal.core.search.matching.TypeReferenceLocator;
import org.eclipse.dltk.internal.core.search.matching.TypeReferencePattern;

public abstract class PatternLocator implements IIndexConstants {
	// store pattern info
	protected int matchMode;
	protected boolean isCaseSensitive;
	protected boolean isCamelCase;
	protected boolean isEquivalentMatch;
	protected boolean isErasureMatch;
	protected Pattern compiledPattern;

	// match to report
	SearchMatch match = null;
	/* match levels */
	public static final int IMPOSSIBLE_MATCH = 0;
	public static final int INACCURATE_MATCH = 1;
	public static final int POSSIBLE_MATCH = 2;
	public static final int ACCURATE_MATCH = 3;
	public static final int ERASURE_MATCH = 4;
	// Possible rule match flavors
	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=79866
	protected static final int POSSIBLE_FULL_MATCH = POSSIBLE_MATCH
			| (SearchPattern.R_FULL_MATCH << 16);
	protected static final int POSSIBLE_PREFIX_MATCH = POSSIBLE_MATCH
			| (SearchPattern.R_PREFIX_MATCH << 16);
	protected static final int POSSIBLE_PATTERN_MATCH = POSSIBLE_MATCH
			| (SearchPattern.R_PATTERN_MATCH << 16);
	protected static final int POSSIBLE_REGEXP_MATCH = POSSIBLE_MATCH
			| (SearchPattern.R_REGEXP_MATCH << 16);
	protected static final int POSSIBLE_CAMELCASE_MATCH = POSSIBLE_MATCH
			| (SearchPattern.R_CAMELCASE_MATCH << 16);
	public static final int NODE_SET_MASK = 0xFF;
	protected static final int POSSIBLE_MATCH_MASK = ~NODE_SET_MASK;
	/* match container */
	public static final int COMPILATION_UNIT_CONTAINER = 1;
	public static final int CLASS_CONTAINER = 2;
	public static final int METHOD_CONTAINER = 4;
	public static final int FIELD_CONTAINER = 8;
	public static final int ALL_CONTAINER = COMPILATION_UNIT_CONTAINER
			| CLASS_CONTAINER | METHOD_CONTAINER | FIELD_CONTAINER;
	/* match rule */
	public static final int RAW_MASK = SearchPattern.R_EQUIVALENT_MATCH
			| SearchPattern.R_ERASURE_MATCH;
	public static final int RULE_MASK = RAW_MASK; // no other values for the

	// while...
	public static PatternLocator patternLocator(SearchPattern pattern,
			IDLTKLanguageToolkit toolkit) {
		switch (((InternalSearchPattern) pattern).kind) {
		// case IIndexConstants.PKG_REF_PATTERN:
		// return new PackageReferenceLocator((PackageReferencePattern)
		// pattern);
		// case IIndexConstants.PKG_DECL_PATTERN:
		// return new PackageDeclarationLocator((PackageDeclarationPattern)
		// pattern);
		case IIndexConstants.TYPE_REF_PATTERN:
			return new TypeReferenceLocator((TypeReferencePattern) pattern);
		case IIndexConstants.TYPE_DECL_PATTERN:
			return new TypeDeclarationLocator((TypeDeclarationPattern) pattern);
		case IIndexConstants.METHOD_DECL_PATTERN:
			return new MethodDeclarationLocator(
					(MethodDeclarationPattern) pattern);
			// case IIndexConstants.SUPER_REF_PATTERN:
			// return new
			// SuperTypeReferenceLocator((SuperTypeReferencePattern)
			// pattern);
			// case IIndexConstants.CONSTRUCTOR_PATTERN:
			// return new ConstructorLocator((ConstructorPattern) pattern);
		case IIndexConstants.FIELD_PATTERN:
			return new FieldLocator((FieldPattern) pattern);
		case IIndexConstants.METHOD_PATTERN:
			return new MethodLocator((MethodPattern) pattern);
		case IIndexConstants.OR_PATTERN:
			return new OrLocator((OrPattern) pattern);
		}
		return null;
	}

	public static char[] qualifiedPattern(char[] simpleNamePattern,
			char[] qualificationPattern) {
		// NOTE: if case insensitive search then simpleNamePattern &
		// qualificationPattern are assumed to be lowercase
		if (simpleNamePattern == null) {
			if (qualificationPattern == null)
				return null;
			return CharOperation.concat(qualificationPattern, ONE_STAR, '.');
		} else {
			return qualificationPattern == null ? CharOperation.concat(
					ONE_STAR, simpleNamePattern) : CharOperation.concat(
					qualificationPattern, simpleNamePattern, '.');
		}
	}

	public PatternLocator(SearchPattern pattern) {
		int matchRule = pattern.getMatchRule();
		this.isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;
		this.isCamelCase = (matchRule & SearchPattern.R_CAMELCASE_MATCH) != 0;
		this.isErasureMatch = (matchRule & SearchPattern.R_ERASURE_MATCH) != 0;
		this.isEquivalentMatch = (matchRule & SearchPattern.R_EQUIVALENT_MATCH) != 0;
		this.matchMode = matchRule & DLTKSearchPattern.MATCH_MODE_MASK;
	}

	/*
	 * Clear caches
	 */
	protected void clear() {
		// nothing to clear by default
	}

	/*
	 * (non-Javadoc) Modify PatternLocator.qualifiedPattern behavior: do not add
	 * star before simple name pattern when qualification pattern is null. This
	 * avoid to match p.X when pattern is only X...
	 */
	protected char[] getQualifiedPattern(char[] simpleNamePattern,
			char[] qualificationPattern) {
		// NOTE: if case insensitive search then simpleNamePattern &
		// qualificationPattern are assumed to be lowercase
		if (simpleNamePattern == null) {
			if (qualificationPattern == null)
				return null;
			return CharOperation.concat(qualificationPattern, ONE_STAR, '.');
		} else if (qualificationPattern == null) {
			return simpleNamePattern;
		} else {
			return CharOperation.concat(qualificationPattern,
					simpleNamePattern, '.');
		}
	}

	/**
	 * Initializes this search pattern so that polymorphic search can be
	 * performed.
	 */
	public void initializePolymorphicSearch(MatchLocator locator) {
		// default is to do nothing
	}

	public int match(Annotation node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	/**
	 * Check if the given ast node syntactically matches this pattern. If it
	 * does, add it to the match set. Returns the match level.
	 */
	public int match(ASTNode node, MatchingNodeSet nodeSet) { // needed for
		// some generic
		// nodes
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(CallExpression node, MatchingNodeSet nodeSet) { // needed
		// for
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(Expression node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(MethodDeclaration node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(Reference node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(TypeReference node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(FieldDeclaration node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	public int match(TypeDeclaration node, MatchingNodeSet nodeSet) {
		// each subtype should override if needed
		return IMPOSSIBLE_MATCH;
	}

	/**
	 * Returns the type(s) of container for this pattern. It is a bit
	 * combination of types, denoting compilation unit, class declarations,
	 * field declarations or method declarations.
	 */
	public int matchContainer() {
		// override if the pattern can be more specific
		return ALL_CONTAINER;
	}

	/**
	 * Returns whether the given name matches the given pattern.
	 */
	protected boolean matchesName(char[] pattern, char[] name) {
		if (pattern == null)
			return true; // null is as if it was "*"
		if (name == null)
			return false; // cannot match null name
		return matchNameValue(pattern, name) != IMPOSSIBLE_MATCH;
	}

	/**
	 * Return how the given name matches the given pattern.
	 * 
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=79866"
	 * 
	 * @param pattern
	 * @param name
	 * @return Possible values are:
	 *         <ul>
	 *         <li>{@link #POSSIBLE_FULL_MATCH}: Given name is equals to pattern
	 *         </li>
	 *         <li>{@link #POSSIBLE_PREFIX_MATCH}: Given name prefix equals to
	 *         pattern</li>
	 *         <li>{@link #POSSIBLE_CAMELCASE_MATCH}: Given name matches pattern
	 *         as Camel Case</li>
	 *         <li>{@link #POSSIBLE_PATTERN_MATCH}: Given name matches pattern
	 *         as Pattern (ie. using '*' and '?' characters)</li>
	 *         </ul>
	 */
	protected int matchNameValue(char[] pattern, char[] name) {
		if (pattern == null)
			return ACCURATE_MATCH; // null is as if it was "*"
		if (name == null)
			return IMPOSSIBLE_MATCH; // cannot match null name
		if (name.length == 0) { // empty name
			if (pattern.length == 0) { // can only matches empty pattern
				return ACCURATE_MATCH;
			}
			return IMPOSSIBLE_MATCH;
		} else if (pattern.length == 0) {
			return IMPOSSIBLE_MATCH; // need to have both name and pattern
			// length==0 to be accurate
		}
		boolean matchFirstChar = !this.isCaseSensitive || pattern[0] == name[0];
		boolean sameLength = pattern.length == name.length;
		boolean canBePrefix = name.length >= pattern.length;
		if (this.isCamelCase && matchFirstChar
				&& CharOperation.camelCaseMatch(pattern, name)) {
			return POSSIBLE_CAMELCASE_MATCH;
		}
		switch (this.matchMode) {
		case SearchPattern.R_EXACT_MATCH:
			if (!this.isCamelCase) {
				if (sameLength
						&& matchFirstChar
						&& CharOperation.equals(pattern, name,
								this.isCaseSensitive)) {
					return POSSIBLE_FULL_MATCH;
				}
				break;
			}
			// fall through next case to match as prefix if camel case
			// failed
		case SearchPattern.R_PREFIX_MATCH:
			if (canBePrefix
					&& matchFirstChar
					&& CharOperation.prefixEquals(pattern, name,
							this.isCaseSensitive)) {
				return POSSIBLE_PREFIX_MATCH;
			}
			break;
		case SearchPattern.R_PATTERN_MATCH:
			if (!this.isCaseSensitive) {
				pattern = CharOperation.toLowerCase(pattern);
			}
			if (CharOperation.match(pattern, name, this.isCaseSensitive)) {
				return POSSIBLE_MATCH;
			}
			break;
		case SearchPattern.R_REGEXP_MATCH:
			if (compiledPattern == null) {
				compiledPattern = Pattern.compile(new String(pattern),
						this.isCaseSensitive ? 0 : Pattern.CASE_INSENSITIVE);
			}
			if (compiledPattern.matcher(new String(name)).matches()) {
				return POSSIBLE_REGEXP_MATCH;
			}
			break;
		}
		return IMPOSSIBLE_MATCH;
	}

	/**
	 * Reports the match of the given reference.
	 */
	protected void matchReportReference(ASTNode reference,
			IModelElement element, int accuracy, MatchLocator locator)
			throws CoreException {
		match = null;
		switch (referenceType()) {
		case IModelElement.TYPE:
			match = locator.newTypeReferenceMatch(element, accuracy, reference
					.matchStart(), reference.matchLength(), reference);
			break;
		case IModelElement.FIELD:
			match = locator.newFieldReferenceMatch(element, accuracy, reference
					.matchStart(), reference.matchLength(), reference);
			break;
		case IModelElement.METHOD:
			match = locator.newMethodReferenceMatch(element, accuracy,
					reference.matchStart(), reference.matchLength(), false,
					false, reference);
			break;
		}
		if (match != null) {
			locator.report(match);
		}
	}

	/**
	 * Reports the match of the given reference. Also provide a local element to
	 * eventually report in match.
	 */
	protected void matchReportReference(ASTNode reference,
			IModelElement element, IModelElement localElement,
			IModelElement[] otherElements, int accuracy, MatchLocator locator)
			throws CoreException {
		matchReportReference(reference, element, accuracy, locator);
	}

	/**
	 * Reports the match of the given reference. Also provide a scope to look
	 * for potential other elements.
	 */
	public void matchReportReference(ASTNode reference, IModelElement element,
			Scope scope, int accuracy, MatchLocator locator)
			throws CoreException {
		matchReportReference(reference, element, accuracy, locator);
	}

	/**
	 * @deprecated
	 */
	@Deprecated
	public final SearchMatch newDeclarationMatch(ASTNode reference,
			IModelElement element, int accuracy, int length,
			MatchLocator locator) {
		return newDeclarationMatch(reference, element, accuracy, locator);
	}

	public SearchMatch newDeclarationMatch(ASTNode reference,
			IModelElement element, int accuracy, MatchLocator locator) {
		return locator.newDeclarationMatch(element, accuracy, reference
				.matchStart(), reference.matchLength());
	}

	protected int referenceType() {
		return 0; // defaults to unknown (a generic JavaSearchMatch will be
		// created)
	}

	/**
	 * Finds out whether the given ast node matches this search pattern. Returns
	 * IMPOSSIBLE_MATCH if it doesn't. Returns INACCURATE_MATCH if it
	 * potentially matches this search pattern (ie. it has already been resolved
	 * but resolving failed.) Returns ACCURATE_MATCH if it matches exactly this
	 * search pattern (ie. it doesn't need to be resolved or it has already been
	 * resolved.)
	 */
	public int resolveLevel(ASTNode possibleMatchingNode) {
		// only called with nodes which were possible matches to the call to
		// matchLevel
		// need to do instance of checks to find out exact type of ASTNode
		return IMPOSSIBLE_MATCH;
	}

	/*
	 * Update pattern locator match comparing type arguments with pattern ones.
	 * Try to resolve pattern and look for compatibility with type arguments to
	 * set match rule.
	 */
	protected void updateMatch(MatchLocator locator, char[][] patternArguments,
			boolean hasTypeParameters) {
		if (DLTKCore.DEBUG) {
			System.err.println("TODO: updateMatch"); //$NON-NLS-1$
		}
	}

	/**
	 * Returns whether the given type binding matches the given simple name
	 * pattern and qualification pattern. Note that this method resolve to
	 * accurate member or local types even if they are not fully qualified (ie.
	 * X.Member instead of p.X.Member). Returns ACCURATE_MATCH if it does.
	 * Returns INACCURATE_MATCH if resolve failed. Returns IMPOSSIBLE_MATCH if
	 * it doesn't.
	 */
	protected int resolveLevelForType(char[] simpleNamePattern,
			char[] qualificationPattern) {
		return INACCURATE_MATCH;
	}

	/**
	 * Returns whether the given type binding matches the given qualified
	 * pattern. Returns ACCURATE_MATCH if it does. Returns INACCURATE_MATCH if
	 * resolve failed. Returns IMPOSSIBLE_MATCH if it doesn't.
	 */
	protected int resolveLevelForType(char[] qualifiedPattern) {
		return IMPOSSIBLE_MATCH;
	}

	@Override
	public String toString() {
		return "SearchPattern"; //$NON-NLS-1$
	}
}