/*******************************************************************************
 * 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.search.matching;

import java.util.List;

import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.expressions.CallExpression;
import org.eclipse.dltk.compiler.CharOperation;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISearchPatternProcessor;
import org.eclipse.dltk.core.search.SearchMatch;
import org.eclipse.dltk.core.search.matching.MatchLocator;
import org.eclipse.dltk.core.search.matching.PatternLocator;

public class MethodDeclarationLocator extends PatternLocator {
	protected MethodDeclarationPattern pattern;

	public MethodDeclarationLocator(MethodDeclarationPattern pattern) {
		super(pattern);
		this.pattern = pattern;
	}

	/*
	 * Clear caches
	 */
	@Override
	protected void clear() {
	}

	@Override
	public void initializePolymorphicSearch(MatchLocator locator) {
	}

	@Override
	public int match(MethodDeclaration node, MatchingNodeSet nodeSet) {
		// Verify method name
		if (!matchesName(this.pattern.simpleName, node.getName().toCharArray()))
			return IMPOSSIBLE_MATCH;

		// Verify parameters types
		List arguments = node.getArguments();
		if (this.pattern.parameterNames != null) {
			int length = this.pattern.parameterNames.length;
			int argsLength = arguments == null ? 0 : arguments.size();
			if (length != argsLength)
				return IMPOSSIBLE_MATCH;
		}

		// check type names
		String declaringType = node.getDeclaringTypeName();
		if (!checkTypeName(declaringType)) {
			return INACCURATE_MATCH;
		}

		// Method declaration may match pattern
		return nodeSet.addMatch(node, ACCURATE_MATCH);
	}

	// public int match(TypeDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
	// public int match(TypeReference node, MatchingNodeSet nodeSet) - SKIP IT
	@Override
	public int matchContainer() {
		return COMPILATION_UNIT_CONTAINER | CLASS_CONTAINER | METHOD_CONTAINER;
	}

	@Override
	public SearchMatch newDeclarationMatch(ASTNode reference,
			IModelElement element, int accuracy, MatchLocator locator) {
		return super.newDeclarationMatch(reference, element, accuracy, locator);
	}

	@Override
	protected int referenceType() {
		return IModelElement.METHOD;
	}

	@Override
	public String toString() {
		return "Locator for " + this.pattern.toString(); //$NON-NLS-1$
	}

	@Override
	public int match(CallExpression node, MatchingNodeSet nodeSet) {
		// this locator matches only declarations
		return IMPOSSIBLE_MATCH;
	}

	@Override
	protected void matchReportReference(ASTNode reference,
			IModelElement element, int accuracy, MatchLocator locator) {
		// Since this is the declaration locator - it is not interested in
		// references.
	}

	/**
	 * Tests if the specified {@code declaringType} matches the search pattern.
	 * Returns <code>true</code> if matches and <code>false</code> otherwise.
	 * 
	 * @param declaringType
	 * @return
	 */
	private boolean checkTypeName(String declaringType) {
		if (this.pattern.enclosingTypeNames != null
				&& this.pattern.enclosingTypeNames.length > 0) {
			if (declaringType != null) {
				ISearchPatternProcessor processor = DLTKLanguageManager
						.getSearchPatternProcessor(this.pattern.getToolkit());
				char[] delimeter = processor != null ? processor
						.getDelimiterReplacementString().toCharArray()
						: new char[] { '.' };
				char[] typeName = this.pattern.enclosingTypeNames[0];
				if (typeName == null) {
					return true;
				}
				for (int i = 1; i < this.pattern.enclosingTypeNames.length; ++i) {
					typeName = CharOperation.concatWithSeparator(typeName,
							this.pattern.enclosingTypeNames[i], delimeter);
				}
				if (!matchesName(typeName, declaringType.toCharArray())) {
					return false;
				}
			} else {
				return false;
			}
		}
		return true;
	}
}