/*******************************************************************************
 * Copyright (c) 2000, 2013 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.core;

import java.util.Map;

import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
import org.eclipse.jdt.internal.compiler.util.SimpleSetOfCharArray;

public class InternalNamingConventions {
	private static final char[] DEFAULT_NAME = "name".toCharArray(); //$NON-NLS-1$

	private static Scanner getNameScanner(CompilerOptions compilerOptions) {
		return
			new Scanner(
				false /*comment*/,
				false /*whitespace*/,
				false /*nls*/,
				compilerOptions.sourceLevel /*sourceLevel*/,
				null /*taskTags*/,
				null/*taskPriorities*/,
				true/*taskCaseSensitive*/);
	}

	private static void acceptName(
		char[] name,
		char[] prefix,
		char[] suffix,
		boolean isFirstPrefix,
		boolean isFirstSuffix,
		int reusedCharacters,
		INamingRequestor requestor) {
		if(prefix.length > 0 && suffix.length > 0) {
			requestor.acceptNameWithPrefixAndSuffix(name, isFirstPrefix, isFirstSuffix, reusedCharacters);
		} else if(prefix.length > 0){
			requestor.acceptNameWithPrefix(name, isFirstPrefix, reusedCharacters);
		} else if(suffix.length > 0){
			requestor.acceptNameWithSuffix(name, isFirstSuffix, reusedCharacters);
		} else {
			requestor.acceptNameWithoutPrefixAndSuffix(name, reusedCharacters);
		}
	}

	private static char[][] computeBaseTypeNames(char[] typeName, boolean isConstantField, char[][] excludedNames){
		if (isConstantField) {
			return computeNonBaseTypeNames(typeName, isConstantField, false);
		} else {
			char[] name = computeBaseTypeNames(typeName[0], excludedNames);
			if(name != null) {
				return new char[][]{name};
			} else {
				// compute variable name like from non base type
				return computeNonBaseTypeNames(typeName, isConstantField, false);
			}
		}
	}
	private static char[] computeBaseTypeNames(char firstName, char[][] excludedNames){
		char[] name = new char[]{firstName};

		for(int i = 0 ; i < excludedNames.length ; i++){
			if(CharOperation.equals(name, excludedNames[i], false)) {
				name[0]++;
				if(name[0] > 'z')
					name[0] = 'a';
				if(name[0] == firstName)
					return null;
				i = 0;
			}
		}

		return name;
	}

	private static char[][] computeNonBaseTypeNames(char[] sourceName, boolean isConstantField, boolean onlyLongest){
		int length = sourceName.length;
		
		if (length == 0) {
			return CharOperation.NO_CHAR_CHAR;
		}
		
		if (length == 1) {
			if (isConstantField) {
				return generateConstantName(new char[][]{CharOperation.toLowerCase(sourceName)}, 0, onlyLongest);
			} else {
				return generateNonConstantName(new char[][]{CharOperation.toLowerCase(sourceName)}, 0, onlyLongest);
			}
		}
		
		char[][] nameParts = new char[length][];
		int namePartsPtr = -1;
		
		int endIndex = length;
		char c = sourceName[length - 1];
		
		final int IS_LOWER_CASE = 1;
		final int IS_UPPER_CASE = 2;
		final int IS_UNDERSCORE = 3;
		final int IS_OTHER = 4;
		
		int previousCharKind =
			ScannerHelper.isLowerCase(c) ? IS_LOWER_CASE :
				ScannerHelper.isUpperCase(c) ? IS_UPPER_CASE :
					c == '_' ? IS_UNDERSCORE : IS_OTHER;
		
		for(int i = length - 1 ; i >= 0 ; i--){
			c = sourceName[i];
			
			int charKind =
				ScannerHelper.isLowerCase(c) ? IS_LOWER_CASE :
					ScannerHelper.isUpperCase(c) ? IS_UPPER_CASE :
						c == '_' ? IS_UNDERSCORE : IS_OTHER;
			
			switch (charKind) {
				case IS_LOWER_CASE:
					if (previousCharKind == IS_UPPER_CASE) {
						nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
						endIndex = i + 1;
					}
					previousCharKind = IS_LOWER_CASE;
					break;
				case IS_UPPER_CASE:
					if (previousCharKind == IS_LOWER_CASE) {
						nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i, endIndex);
						if (i > 0) {
							char pc = sourceName[i - 1];
							previousCharKind =
								ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
									ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
										pc == '_' ? IS_UNDERSCORE : IS_OTHER;
						}
						endIndex = i;
					} else {
						previousCharKind = IS_UPPER_CASE;
					}
					break;
				case IS_UNDERSCORE:
					switch (previousCharKind) {
						case IS_UNDERSCORE:
							// https://bugs.eclipse.org/bugs/show_bug.cgi?id=283539
							// Process consecutive underscores only for constant types 
							if (isConstantField) {
								if (i > 0) {
									char pc = sourceName[i - 1];
									previousCharKind =
										ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
											ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
												pc == '_' ? IS_UNDERSCORE : IS_OTHER;
								}
								endIndex = i;
							}
							break;
						case IS_LOWER_CASE:
						case IS_UPPER_CASE:
							nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, i + 1, endIndex);
							if (i > 0) {
								char pc = sourceName[i - 1];
								previousCharKind =
									ScannerHelper.isLowerCase(pc) ? IS_LOWER_CASE :
										ScannerHelper.isUpperCase(pc) ? IS_UPPER_CASE :
											pc == '_' ? IS_UNDERSCORE : IS_OTHER;
							}
							// Include the '_' also. E.g. My_word -> "My_" and "word".
							endIndex = i+1;
							break;
						default:
							previousCharKind = IS_UNDERSCORE;
							break;
					}
					break;
				default:
					previousCharKind = IS_OTHER;
					break;
			}
		}
		if (endIndex > 0) {
			nameParts[++namePartsPtr] = CharOperation.subarray(sourceName, 0, endIndex);
		}
		if (namePartsPtr == -1) {
			return new char[][] { sourceName };
		}
		
		if (isConstantField) {
			return generateConstantName(nameParts, namePartsPtr, onlyLongest);
		} else {
			return generateNonConstantName(nameParts, namePartsPtr, onlyLongest);
		}
	}
	
	

	private static char[] excludeNames(
		char[] suffixName,
		char[] prefixName,
		char[] suffix,
		char[][] excludedNames) {
		int count = 2;
		int m = 0;
		while (m < excludedNames.length) {
			if(CharOperation.equals(suffixName, excludedNames[m], false)) {
				suffixName = CharOperation.concat(
					prefixName,
					String.valueOf(count++).toCharArray(),
					suffix
				);
				m = 0;
			} else {
				m++;
			}
		}
		return suffixName;
	}
	
	private static char[][] generateNonConstantName(char[][] nameParts, int namePartsPtr, boolean onlyLongest) {
		char[][] names;
		if (onlyLongest) {
			names = new char[1][];
		} else {
			names = new char[namePartsPtr + 1][];
		}
		
		char[] namePart = nameParts[0];
		
		char[] name = CharOperation.toLowerCase(namePart);
		
		if (!onlyLongest) {
			names[namePartsPtr] = name;
		}
		
		char[] nameSuffix = namePart;
		
		for (int i = 1; i <= namePartsPtr; i++) {
			namePart = nameParts[i];
			
			name = CharOperation.concat(CharOperation.toLowerCase(namePart), nameSuffix);
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=283539
			// Only the first word is converted to lower case and the rest of them are not changed for non-constants
			
			if (!onlyLongest) {
				names[namePartsPtr - i] = name;
			}
			
			nameSuffix = CharOperation.concat(namePart, nameSuffix);
		}
		if (onlyLongest) {
			names[0] = name;
		}
		return names;
	}

	private static char[][] generateConstantName(char[][] nameParts, int namePartsPtr, boolean onlyLongest) {
		char[][] names;
		if (onlyLongest) {
			names = new char[1][];
		} else {
			names = new char[namePartsPtr + 1][];
		}
		
		char[] namePart = CharOperation.toUpperCase(nameParts[0]);
		int namePartLength = namePart.length;
		System.arraycopy(namePart, 0, namePart, 0, namePartLength);
		
		char[] name = namePart;
		
		if (!onlyLongest) {
			names[namePartsPtr] = name;
		}
		
		for (int i = 1; i <= namePartsPtr; i++) {
			namePart = CharOperation.toUpperCase(nameParts[i]);
			namePartLength = namePart.length;
			if (namePart[namePartLength - 1] != '_') {
				name = CharOperation.concat(namePart, name, '_');
			} else {
				name = CharOperation.concat(namePart, name);
			}
			
			if (!onlyLongest) {
				names[namePartsPtr - i] = name;
			}
		}
		if (onlyLongest) {
			names[0] = name;
		}
		return names;
	}
	
	public static char[] getBaseName(
			int variableKind,
			IJavaProject javaProject,
			char[] name,
			boolean updateFirstCharacter) {
		
		AssistOptions assistOptions;
		if (javaProject != null) {
			assistOptions = new AssistOptions(javaProject.getOptions(true));
		} else {
			assistOptions = new AssistOptions(JavaCore.getOptions());
		}
		
		char[][] prefixes = null;
		char[][] suffixes = null;
		switch (variableKind) {
			case VK_INSTANCE_FIELD:
				prefixes = assistOptions.fieldPrefixes;
				suffixes = assistOptions.fieldSuffixes;
				break;
			case VK_STATIC_FIELD:
				prefixes = assistOptions.staticFieldPrefixes;
				suffixes = assistOptions.staticFieldSuffixes;
				break;
			case VK_STATIC_FINAL_FIELD:
				prefixes = assistOptions.staticFinalFieldPrefixes;
				suffixes = assistOptions.staticFinalFieldSuffixes;
				break;
			case VK_LOCAL:
				prefixes = assistOptions.localPrefixes;
				suffixes = assistOptions.localSuffixes;
				break;
			case VK_PARAMETER:
				prefixes = assistOptions.argumentPrefixes;
				suffixes = assistOptions.argumentSuffixes;
				break;
		}
		
		
		return getBaseName(name, prefixes, suffixes, variableKind == VK_STATIC_FINAL_FIELD, updateFirstCharacter);
	}

	private static char[] getBaseName(char[] name, char[][] prefixes, char[][] suffixes, boolean isConstant, boolean updateFirstCharacter) {
		char[] nameWithoutPrefixAndSiffix = removeVariablePrefixAndSuffix(name, prefixes, suffixes, updateFirstCharacter);
		
		char[] baseName;
		if (isConstant) {
			int length = nameWithoutPrefixAndSiffix.length;
			baseName = new char[length];
			int baseNamePtr = -1;
			
			boolean previousIsUnderscore = false;
			for (int i = 0; i < length; i++) {
				char c = nameWithoutPrefixAndSiffix[i];
				if (c != '_') {
					if (previousIsUnderscore) {
						baseName[++baseNamePtr] = ScannerHelper.toUpperCase(c);
						previousIsUnderscore = false;
					} else {
						baseName[++baseNamePtr] = ScannerHelper.toLowerCase(c);
					}
				} else {
					previousIsUnderscore = true;
				}
			}
			System.arraycopy(baseName, 0, baseName = new char[baseNamePtr + 1], 0, baseNamePtr + 1);
		} else {
			baseName = nameWithoutPrefixAndSiffix;
		}
		
		return baseName;
	}
	
	public static char[] removeVariablePrefixAndSuffix(
			int variableKind,
			IJavaProject javaProject,
			char[] name) {
		AssistOptions assistOptions;
		if (javaProject != null) {
			assistOptions = new AssistOptions(javaProject.getOptions(true));
		} else {
			assistOptions = new AssistOptions(JavaCore.getOptions());
		}
		
		char[][] prefixes = null;
		char[][] suffixes = null;
		switch (variableKind) {
			case VK_INSTANCE_FIELD:
				prefixes = assistOptions.fieldPrefixes;
				suffixes = assistOptions.fieldSuffixes;
				break;
			case VK_STATIC_FIELD:
				prefixes = assistOptions.staticFieldPrefixes;
				suffixes = assistOptions.staticFieldSuffixes;
				break;
			case VK_STATIC_FINAL_FIELD:
				prefixes = assistOptions.staticFinalFieldPrefixes;
				suffixes = assistOptions.staticFinalFieldSuffixes;
				break;
			case VK_LOCAL:
				prefixes = assistOptions.localPrefixes;
				suffixes = assistOptions.localSuffixes;
				break;
			case VK_PARAMETER:
				prefixes = assistOptions.argumentPrefixes;
				suffixes = assistOptions.argumentSuffixes;
				break;
		}
		
		return InternalNamingConventions.removeVariablePrefixAndSuffix(name, prefixes, suffixes, true);
	}
	
	private static char[] removeVariablePrefixAndSuffix(char[] name, char[][] prefixes, char[][] suffixes, boolean updateFirstCharacter) {
		// remove longer prefix
		char[] withoutPrefixName = name;
		if (prefixes != null) {
			int bestLength = 0;
			for (int i= 0; i < prefixes.length; i++) {
				char[] prefix = prefixes[i];
				if (CharOperation.prefixEquals(prefix, name)) {
					int currLen = prefix.length;
					boolean lastCharIsLetter = ScannerHelper.isLetter(prefix[currLen - 1]);
					if(!lastCharIsLetter || (lastCharIsLetter && name.length > currLen && ScannerHelper.isUpperCase(name[currLen]))) {
						if (bestLength < currLen && name.length != currLen) {
							withoutPrefixName = CharOperation.subarray(name, currLen, name.length);
							bestLength = currLen;
						}
					}
				}
			}
		}

		// remove longer suffix
		char[] withoutSuffixName = withoutPrefixName;
		if(suffixes != null) {
			int bestLength = 0;
			for (int i = 0; i < suffixes.length; i++) {
				char[] suffix = suffixes[i];
				if(CharOperation.endsWith(withoutPrefixName, suffix)) {
					int currLen = suffix.length;
					if(bestLength < currLen && withoutPrefixName.length != currLen) {
						withoutSuffixName = CharOperation.subarray(withoutPrefixName, 0, withoutPrefixName.length - currLen);
						bestLength = currLen;
					}
				}
			}
		}

		if (updateFirstCharacter) withoutSuffixName[0] = ScannerHelper.toLowerCase(withoutSuffixName[0]);
		return withoutSuffixName;
	}

	private static char[] removePrefix(char[] name, char[][] prefixes) {
		// remove longer prefix
		char[] withoutPrefixName = name;
		if (prefixes != null) {
			int bestLength = 0;
			int nameLength = name.length;
			for (int i= 0; i < prefixes.length; i++) {
				char[] prefix = prefixes[i];

				int prefixLength = prefix.length;
				if(prefixLength <= nameLength) {
					if(CharOperation.prefixEquals(prefix, name, false)) {
						if (prefixLength > bestLength) {
							bestLength = prefixLength;
						}
					}
				} else {
					int currLen = 0;
					for (; currLen < nameLength; currLen++) {
						if(ScannerHelper.toLowerCase(prefix[currLen]) != ScannerHelper.toLowerCase(name[currLen])) {
							if (currLen > bestLength) {
								bestLength = currLen;
							}
							break;
						}
					}
					if(currLen == nameLength && currLen > bestLength) {
						bestLength = currLen;
					}
				}
			}
			if(bestLength > 0) {
				if(bestLength == nameLength) {
					withoutPrefixName = CharOperation.NO_CHAR;
				} else {
					withoutPrefixName = CharOperation.subarray(name, bestLength, nameLength);
				}
			}
		}
//
//
//		// remove longer prefix
//		char[] withoutPrefixName = name;
//		if (prefixes != null) {
//			int bestLength = 0;
//			for (int i= 0; i < prefixes.length; i++) {
//				char[] prefix = prefixes[i];
//				int max = prefix.length < name.length ? prefix.length : name.length;
//				int currLen = 0;
//				for (; currLen < max; currLen++) {
//					if(Character.toLowerCase(prefix[currLen]) != Character.toLowerCase(name[currLen])) {
//						if (currLen > bestLength) {
//							bestLength = currLen;
//						}
//						break;
//					}
//				}
//				if(currLen == max && currLen > bestLength) {
//					bestLength = max;
//				}
//			}
//			if(bestLength > 0) {
//				if(bestLength == name.length) {
//					withoutPrefixName = CharOperation.NO_CHAR;
//				} else {
//					withoutPrefixName = CharOperation.subarray(name, bestLength, name.length);
//				}
//			}
//		}

		return withoutPrefixName;
	}
	
	public static final int VK_STATIC_FIELD = 1;
	public static final int VK_INSTANCE_FIELD = 2;
	public static final int VK_STATIC_FINAL_FIELD = 3;
	public static final int VK_PARAMETER = 4;
	public static final int VK_LOCAL = 5;
	
	public static final int BK_SIMPLE_NAME = 1;
	public static final int BK_SIMPLE_TYPE_NAME = 2;

	public static void suggestVariableNames(
			int variableKind,
			int baseNameKind,
			char[] baseName,
			IJavaProject javaProject,
			int dim,
			char[] internalPrefix,
			char[][] excluded,
			boolean evaluateDefault,
			INamingRequestor requestor) {
		
		if(baseName == null || baseName.length == 0)
			return;
		
		Map<String, String> options;
		if (javaProject != null) {
			options = javaProject.getOptions(true);
		} else {
			options = JavaCore.getOptions();
		}
		CompilerOptions compilerOptions = new CompilerOptions(options);
		AssistOptions assistOptions = new AssistOptions(options);
		
		boolean isConstantField = false;
		
		char[][] prefixes = null;
		char[][] suffixes = null;
		switch (variableKind) {
			case VK_INSTANCE_FIELD:
				prefixes = assistOptions.fieldPrefixes;
				suffixes = assistOptions.fieldSuffixes;
				break;
			case VK_STATIC_FIELD:
				prefixes = assistOptions.staticFieldPrefixes;
				suffixes = assistOptions.staticFieldSuffixes;
				break;
			case VK_STATIC_FINAL_FIELD:
				isConstantField = true;
				prefixes = assistOptions.staticFinalFieldPrefixes;
				suffixes = assistOptions.staticFinalFieldSuffixes;
				break;
			case VK_LOCAL:
				prefixes = assistOptions.localPrefixes;
				suffixes = assistOptions.localSuffixes;
				break;
			case VK_PARAMETER:
				prefixes = assistOptions.argumentPrefixes;
				suffixes = assistOptions.argumentSuffixes;
				break;
		}
		
		if(prefixes == null || prefixes.length == 0) {
			prefixes = new char[1][0];
		} else {
			int length = prefixes.length;
			System.arraycopy(prefixes, 0, prefixes = new char[length+1][], 0, length);
			prefixes[length] = CharOperation.NO_CHAR;
		}

		if(suffixes == null || suffixes.length == 0) {
			suffixes = new char[1][0];
		} else {
			int length = suffixes.length;
			System.arraycopy(suffixes, 0, suffixes = new char[length+1][], 0, length);
			suffixes[length] = CharOperation.NO_CHAR;
		}
		
		if(internalPrefix == null) {
			internalPrefix = CharOperation.NO_CHAR;
		} else {
			internalPrefix = removePrefix(internalPrefix, prefixes);
		}

		char[][] tempNames = null;
		
		Scanner nameScanner = getNameScanner(compilerOptions);
		if (baseNameKind == BK_SIMPLE_TYPE_NAME) {
			boolean isBaseType = false;
			
			try{
				nameScanner.setSource(baseName);
				switch (nameScanner.getNextToken()) {
					case TerminalTokens.TokenNameint :
					case TerminalTokens.TokenNamebyte :
					case TerminalTokens.TokenNameshort :
					case TerminalTokens.TokenNamechar :
					case TerminalTokens.TokenNamelong :
					case TerminalTokens.TokenNamefloat :
					case TerminalTokens.TokenNamedouble :
					case TerminalTokens.TokenNameboolean :
						isBaseType = true;
						break;
				}
			} catch(InvalidInputException e){
				// ignore
			}
			if (isBaseType) {
				// compute variable name from base type
				if (internalPrefix.length > 0) return;
	
				tempNames = computeBaseTypeNames(baseName, isConstantField, excluded);
			} else {
				// compute variable name for non base type
				tempNames = computeNonBaseTypeNames(baseName, isConstantField, false);
			}
		} else {
			tempNames = computeNonBaseTypeNames(baseName, isConstantField, true);
		}

		boolean acceptDefaultName = true;
		SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();

		for (int i = 0; i < tempNames.length; i++) {
			char[] tempName = tempNames[i];
			
			// add English plural form is necessary
			if(dim > 0) {
				int length = tempName.length;
				
				if (isConstantField) {
					if (tempName[length-1] == 'S'){
						if(tempName.length > 1 && tempName[length-2] == 'S') {
							System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
							tempName[length] = 'E';
							tempName[length+1] = 'S';
						}
					} else if(tempName[length-1] == 'Y') {
						boolean precededByAVowel = false;
						if(tempName.length > 1) {
							switch (tempName[length-2]) {
								case 'A':
								case 'E':
								case 'I':
								case 'O':
								case 'U':
									precededByAVowel = true;
									break;
							}
						}
						if (precededByAVowel) {
							System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
							tempName[length] = 'S';
						} else {
							System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
							tempName[length-1] = 'I';
							tempName[length] = 'E';
							tempName[length+1] = 'S';
						}
					} else {
						System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
						tempName[length] = 'S';
					}
				} else {
					if (tempName[length-1] == 's'){
						if(tempName.length > 1 && tempName[length-2] == 's') {
							System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
							tempName[length] = 'e';
							tempName[length+1] = 's';
						}
					} else if(tempName[length-1] == 'y') {
						boolean precededByAVowel = false;
						if(tempName.length > 1) {
							switch (tempName[length-2]) {
								case 'a':
								case 'e':
								case 'i':
								case 'o':
								case 'u':
									precededByAVowel = true;
									break;
							}
						}
						if (precededByAVowel) {
							System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
							tempName[length] = 's';
						} else {
							System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
							tempName[length-1] = 'i';
							tempName[length] = 'e';
							tempName[length+1] = 's';
						}
					} else {
						System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
						tempName[length] = 's';
					}
				}
			}
			
			char[] unprefixedName = tempName;
			
			int matchingIndex = -1;
			if (!isConstantField) {
				unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
				
				done : for (int j = 0; j <= internalPrefix.length; j++) {
					if(j == internalPrefix.length ||
							CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
						matchingIndex = j;
						break done;
					}
				}
			} else {
				done : for (int j = 0; j <= internalPrefix.length; j++) {
					if(j == internalPrefix.length) {
						matchingIndex = j;
						break done;
					} else if(CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
						if (j == 0 || internalPrefix[j - 1] == '_') {
							matchingIndex = j;
							break done;
						}
						
					}
				}
			}

			if(matchingIndex > -1) {
				if (!isConstantField) {
					tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, matchingIndex), unprefixedName);
					if(matchingIndex == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
				} else {
					if(matchingIndex != 0 && tempName[0] != '_' && internalPrefix[matchingIndex - 1] != '_') {
						tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName, '_');
					} else {
						tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName);
					}
				}
				
				for (int k = 0; k < prefixes.length; k++) {
					if (!isConstantField) {
						if(prefixes[k].length > 0
							&& ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
							tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
						} else {
							tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
						}
					}
					char[] prefixName = CharOperation.concat(prefixes[k], tempName);
					for (int l = 0; l < suffixes.length; l++) {
						char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
						suffixName =
							excludeNames(
								suffixName,
								prefixName,
								suffixes[l],
								excluded);
						try{
							nameScanner.setSource(suffixName);
							switch (nameScanner.getNextToken()) {
								case TerminalTokens.TokenNameIdentifier :
									int token = nameScanner.getNextToken();
									if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
										if (!foundNames.includes(suffixName)) {
											acceptName(suffixName, prefixes[k], suffixes[l],  k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
											foundNames.add(suffixName);
											acceptDefaultName = false;
										}
									}
									break;
								default:
									suffixName = CharOperation.concat(
										prefixName,
										String.valueOf(1).toCharArray(),
										suffixes[l]
									);
									suffixName =
										excludeNames(
											suffixName,
											prefixName,
											suffixes[l],
											excluded);
									nameScanner.setSource(suffixName);
									switch (nameScanner.getNextToken()) {
										case TerminalTokens.TokenNameIdentifier :
											token = nameScanner.getNextToken();
											if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
												if (!foundNames.includes(suffixName)) {
													acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
													foundNames.add(suffixName);
													acceptDefaultName = false;
												}
											}
									}
							}
						} catch(InvalidInputException e){
							// ignore
						}
					}
				}
			}
		}
		// if no names were found
		if(evaluateDefault && acceptDefaultName) {
			char[] name = excludeNames(DEFAULT_NAME, DEFAULT_NAME, CharOperation.NO_CHAR, excluded);
			requestor.acceptNameWithoutPrefixAndSuffix(name, 0);
		}
	}
}
