package gr.uom.java.ast.decomposition.matching.loop;

import gr.uom.java.ast.decomposition.matching.conditional.AbstractControlStructureUtilities;
import gr.uom.java.ast.util.ExpressionExtractor;
import gr.uom.java.ast.util.StatementExtractor;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NumberLiteral;
import org.eclipse.jdt.core.dom.PostfixExpression;
import org.eclipse.jdt.core.dom.PrefixExpression;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.TryStatement;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;

@SuppressWarnings("unchecked")
public class AbstractLoopUtilities
{
	public static boolean isUpdatingVariable(Expression updater, SimpleName variable)
	{
		if (updater instanceof PrefixExpression)
		{
			PrefixExpression prefixExpression = (PrefixExpression) updater;
			return isSameVariable(prefixExpression.getOperand(), variable);
		}
		else if (updater instanceof PostfixExpression)
		{
			PostfixExpression postfixExpression = (PostfixExpression) updater;
			return isSameVariable(postfixExpression.getOperand(), variable);			
		}
		else if (updater instanceof Assignment)
		{
			Assignment assignment = (Assignment) updater;
			return isSameVariable(assignment.getLeftHandSide(), variable);
		}
		else if (updater instanceof MethodInvocation)
		{
			MethodInvocation methodInvocation = (MethodInvocation) updater;
			return isSameVariable(methodInvocation.getExpression(), variable);
		}
		return false;
	}
	
	private static boolean isSameVariable(Expression expression, SimpleName variable)
	{
		if (expression instanceof SimpleName)
		{
			SimpleName simpleNameOperand = (SimpleName) expression;
			return variable.resolveBinding().isEqualTo(simpleNameOperand.resolveBinding());
		}
		return false;
	}
	
	public static boolean isCollectionSizeInvocation(Expression expression)
	{
		if (expression instanceof MethodInvocation)
		{
			MethodInvocation methodInvocation = (MethodInvocation) expression;
			Expression callingExpression      = methodInvocation.getExpression();
			IMethodBinding methodBinding      = methodInvocation.resolveMethodBinding();
			if (methodBinding != null && callingExpression != null)
			{
				return (methodBinding.getName().equals("size") && AbstractLoopUtilities.isCollection(callingExpression.resolveTypeBinding()));
			}
		}
		return false;
	}
	
	public static boolean isDataStructureSizeInvocation(Expression expression)
	{
		if (expression instanceof MethodInvocation)
		{
			MethodInvocation methodInvocation = (MethodInvocation) expression;
			Expression callingExpression      = methodInvocation.getExpression();
			IMethodBinding methodBinding      = methodInvocation.resolveMethodBinding();
			if (methodBinding != null && callingExpression != null)
			{
				AbstractLoopBindingInformation bindingInformation = AbstractLoopBindingInformation.getInstance();
				return bindingInformation.dataStructureSizeMethodContains(methodBinding.getKey());
			}
		}
		return false;
	}
	
	public static boolean isLengthFieldAccess(Expression expression)
	{
		SimpleName name          = null;
		ITypeBinding typeBinding = null;
		if (expression instanceof QualifiedName)
		{
			QualifiedName qualifiedName = (QualifiedName) expression;
			name                        = qualifiedName.getName();
			Name qualifier              = qualifiedName.getQualifier();
			typeBinding                 = qualifier.resolveTypeBinding();
		}
		else if (expression instanceof FieldAccess)
		{
			FieldAccess fieldAccess           = (FieldAccess)expression;
			name                              = fieldAccess.getName();
			Expression fieldAsccessExpression = fieldAccess.getExpression();
			typeBinding                       = fieldAsccessExpression.resolveTypeBinding();
		}
		if (name != null && typeBinding != null)
		{
			IBinding nameBinding = name.resolveBinding();
			if (nameBinding != null && nameBinding.getKind() == IBinding.VARIABLE && typeBinding != null)
			{
				IVariableBinding nameVariableBinding = (IVariableBinding) nameBinding;
				return (nameVariableBinding.getName().equals("length") && typeBinding.isArray());
			}
		}
		return false;
	}
	
	public static boolean isCollection(ITypeBinding typeBinding)
	{
		return isSubclassOf(typeBinding, "java.util.AbstractCollection") || isSubinterfaceOf(typeBinding, "java.util.Collection") ||
				isSubinterfaceOf(typeBinding, "java.lang.Iterable");
	}
	
	public static boolean isSubclassOf(ITypeBinding typeBinding, String qualifiedName)
	{
		do
		{
			if (typeBinding.getQualifiedName().startsWith(qualifiedName))
			{
				return true;
			}
			typeBinding = typeBinding.getSuperclass();
		} while (typeBinding != null);
		return false;
	}
	
	public static boolean isSubinterfaceOf(ITypeBinding typeBinding, String qualifiedName)
	{
		if (typeBinding.getQualifiedName().startsWith(qualifiedName))
		{
			return true;
		}
		else
		{
			ITypeBinding[] superInterfaces = typeBinding.getInterfaces();
			for (ITypeBinding superInterface : superInterfaces)
			{
				if (isSubinterfaceOf(superInterface, qualifiedName))
				{
					return true;
				}
			}
			return false;
		}
	}

	public static VariableDeclaration getVariableDeclaration(SimpleName variable)
	{
		VariableDeclaration variableDeclaration        = null;
		MethodDeclaration method                       = findParentMethodDeclaration(variable);
		List<VariableDeclaration> variableDeclarations = getAllVariableDeclarations(method);
		// find the variable's initializer
		IBinding binding = variable.resolveBinding();
		if (binding.getKind() == IBinding.VARIABLE)
		{
			IVariableBinding variableBinding = (IVariableBinding) binding;
			for (VariableDeclaration currentVariableDeclaration : variableDeclarations)
			{
				IVariableBinding currentVariableDeclarationBinding = currentVariableDeclaration.resolveBinding();
				if (currentVariableDeclarationBinding.isEqualTo(variableBinding))
				{
					variableDeclaration = currentVariableDeclaration;
					break;
				}
			}
		}
		return variableDeclaration;
	}
	
	private static List<VariableDeclaration> getAllVariableDeclarations(MethodDeclaration method)
	{
		StatementExtractor statementExtractor            = new StatementExtractor();
		ExpressionExtractor expressionExtractor          = new ExpressionExtractor();
		List<SingleVariableDeclaration> methodParameters = method.parameters();
		Block methodBody                                 = method.getBody();
		List<Statement> variableDeclarationStatements    = statementExtractor.getVariableDeclarationStatements(methodBody);
		List<Expression> variableDeclarationExpressions  = expressionExtractor.getVariableDeclarationExpressions(methodBody);
		List<Statement> enhancedForStatements            = statementExtractor.getEnhancedForStatements(methodBody);
		List<VariableDeclaration> variableDeclarations   = new ArrayList<VariableDeclaration>(methodParameters);
		if (method.getParent() instanceof TypeDeclaration)
		{
			TypeDeclaration typeDeclaration = (TypeDeclaration) method.getParent();
			FieldDeclaration[] fieldDeclarations = typeDeclaration.getFields();
			for (FieldDeclaration fieldDeclaration : fieldDeclarations)
			{
				List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
				variableDeclarations.addAll(fragments);
			}
		}
		for (Statement currentStatement : variableDeclarationStatements)
		{
			if (currentStatement instanceof VariableDeclarationStatement)
			{
				VariableDeclarationStatement currentVariableDeclarationStatement = (VariableDeclarationStatement) currentStatement;
				variableDeclarations.addAll(currentVariableDeclarationStatement.fragments());
			}
		}
		for (Expression currentExpression : variableDeclarationExpressions)
		{
			if (currentExpression instanceof VariableDeclarationExpression)
			{
				VariableDeclarationExpression currentVariableDeclarationExpression = (VariableDeclarationExpression) currentExpression;
				variableDeclarations.addAll(currentVariableDeclarationExpression.fragments());
			}
		}
		for (Statement currentStatement : enhancedForStatements)
		{
			if (currentStatement instanceof EnhancedForStatement)
			{
				EnhancedForStatement currentEnhancedForStatement = (EnhancedForStatement) currentStatement;
				variableDeclarations.add(currentEnhancedForStatement.getParameter());
			}
		}
		return variableDeclarations;
	}

	public static MethodDeclaration findParentMethodDeclaration(ASTNode node)
	{
		MethodDeclaration parentMethodDeclaration = null;
		ASTNode parent = node.getParent();
		while (parent != null)
		{
			if (parent instanceof MethodDeclaration)
			{
				parentMethodDeclaration = (MethodDeclaration) parent;
				break;
			}
			parent = parent.getParent();
		}
		return parentMethodDeclaration;
	}
	
	// returns null if the main variable (LHS in an assignment, expression in postfix, prefix, or methodInvocation) is not being UPDATED
	public static Integer getUpdateValue(Expression updater)
	{
		if (updater instanceof PrefixExpression || updater instanceof PostfixExpression)
		{
			return AbstractLoopUtilities.getIncrementValue(updater);
		}
		else if (updater instanceof Assignment)
		{
			Assignment assignment = (Assignment) updater;
			return assignmentUpdateValue(assignment);
		}
		else if (updater instanceof MethodInvocation)
		{
			MethodInvocation methodInvocation = (MethodInvocation) updater;
			AbstractLoopBindingInformation bindingInformation = AbstractLoopBindingInformation.getInstance();
			return bindingInformation.getUpdateMethodValue(methodInvocation.resolveMethodBinding().getMethodDeclaration().getKey());
		}
		return null;
	}

	// returns null if specified expression is not a Prefix or PostfixExpression
	private static Integer getIncrementValue(Expression expression)
	{
		Integer incrementValue = null;
		String operator = null;
		if (expression instanceof PrefixExpression)
		{
			PrefixExpression prefixExpression  = (PrefixExpression) expression;
			operator = prefixExpression.getOperator().toString();
		}
		else if (expression instanceof PostfixExpression)
		{
			PostfixExpression postfixExpression = (PostfixExpression) expression;
			operator = postfixExpression.getOperator().toString();
		}
		if (operator != null && operator.equals("++"))
		{
			incrementValue = 1;
		}
		else if (operator != null && operator.equals("--"))
		{
			incrementValue = (-1);
		}
		return incrementValue;
	}

	// returns null if the assignment is not UPDATING the variable on the left hand side or if the updateValue cannot be evaluated to an integer
	private static Integer assignmentUpdateValue(Assignment assignment)
	{
		Integer updateValue          = null;
		Expression leftHandSide      = assignment.getLeftHandSide();
		Assignment.Operator operator = assignment.getOperator();
		Expression rightHandSide     = assignment.getRightHandSide();
		if (operator == Assignment.Operator.PLUS_ASSIGN)
		{			
			updateValue = AbstractLoopUtilities.getIntegerValue(rightHandSide);
		}
		else if (operator == Assignment.Operator.MINUS_ASSIGN)
		{
			Integer rightHandSideIntegerValue = AbstractLoopUtilities.getIntegerValue(rightHandSide);
			if (rightHandSideIntegerValue != null)
			{
				updateValue = (-1) * rightHandSideIntegerValue;
			}
		}
		else if (leftHandSide instanceof SimpleName && operator == Assignment.Operator.ASSIGN && rightHandSide instanceof InfixExpression)
		{
			SimpleName leftHandSideSimpleName      = (SimpleName) leftHandSide;
			IBinding leftHandSideBinding           = leftHandSideSimpleName.resolveBinding();
			InfixExpression infixExpression        = (InfixExpression) rightHandSide;
			InfixExpression.Operator infixOperator = infixExpression.getOperator();
			Expression rightOperand                = infixExpression.getRightOperand();
			Expression leftOperand                 = infixExpression.getLeftOperand();
			if (infixOperator.toString().equals("+") || infixOperator.toString().equals("-"))
			{
				if (leftOperand instanceof SimpleName)
				{
					SimpleName leftOperandSimpleName = (SimpleName) leftOperand;
					IBinding leftOperandBinding      = leftOperandSimpleName.resolveBinding();
					if (leftOperandBinding.isEqualTo(leftHandSideBinding))
					{
						Integer rightOperandIntegerValue = AbstractLoopUtilities.getIntegerValue(rightOperand);
						if (infixOperator.toString().equals("+") && rightOperandIntegerValue != null)
						{
							updateValue = rightOperandIntegerValue;
						}
						else if (infixOperator.toString().equals("-") && rightOperandIntegerValue != null)
						{
							updateValue = (-1) * rightOperandIntegerValue;
						}
					}
				}
				else if (rightOperand instanceof SimpleName)
				{
					SimpleName rightOperandSimpleName = (SimpleName) rightOperand;
					IBinding rightOperandBinding      = rightOperandSimpleName.resolveBinding();
					if (rightOperandBinding.isEqualTo(leftHandSideBinding))
					{
						Integer leftOperandIntegerValue = AbstractLoopUtilities.getIntegerValue(leftOperand);
						if (infixOperator.toString().equals("+") && leftOperandIntegerValue != null)
						{
							updateValue = leftOperandIntegerValue;
						}
					}
				}
			}
		}
		return updateValue;
	}
	
	// returns null if specified expression cannot be evaluated to an Integer
	public static Integer getIntegerValue(Expression expression)
	{
		Integer numberLiteralValue = null;
		if (expression instanceof NumberLiteral)
		{
			NumberLiteral numberLiteral = (NumberLiteral) expression;
			try
			{
				numberLiteralValue = Integer.parseInt(numberLiteral.getToken());
			}
			catch (NumberFormatException e) {}
		}
		else if (expression instanceof PrefixExpression)
		{
			PrefixExpression prefixExpression        = (PrefixExpression) expression;
			PrefixExpression.Operator prefixOperator = prefixExpression.getOperator();
			Expression operand                       = prefixExpression.getOperand();
			if (operand instanceof NumberLiteral && (prefixOperator.toString().equals("+") || prefixOperator.toString().equals("-")))
			{
				NumberLiteral numberLiteral = (NumberLiteral) operand;
				try
				{
					numberLiteralValue = Integer.parseInt(prefixOperator.toString() + numberLiteral.getToken());
				}
				catch (NumberFormatException e) {}
			}
		}
		return numberLiteralValue;
	}
	
	// returns a boolean indicating which side of the specified infixExpression the specified variable is on
	// returns null if it is on neither side
	public static boolean isVariableLeftOperand(SimpleName variable, InfixExpression infixExpression)
	{
		boolean leftOperandIsVariable     = false;
		Expression leftOperand            = infixExpression.getLeftOperand();
		//Expression rightOperand           = infixExpression.getRightOperand();
		IBinding infixVariableBinding     = variable.resolveBinding();
		if (leftOperand instanceof SimpleName)
		{
			SimpleName leftOperandSimpleName = (SimpleName) leftOperand;
			IBinding leftOperandBinding      = leftOperandSimpleName.resolveBinding();
			if (leftOperandBinding.isEqualTo(infixVariableBinding))
			{
				leftOperandIsVariable = true;
			}
		}
		else if (leftOperand instanceof InfixExpression)
		{
			InfixExpression infixLeftOperand = (InfixExpression) leftOperand;
			boolean left = isVariableLeftOperand(variable, infixLeftOperand);
			boolean right = isVariableRightOperand(variable, infixLeftOperand);
			List<Expression> extendedOperands = infixLeftOperand.extendedOperands();
			boolean variableFoundInExtendedOperands = false;
			for (Expression expression : extendedOperands)
			{
				if (expression instanceof SimpleName)
				{
					SimpleName simpleName = (SimpleName) expression;
					IBinding simpleNameBinding = simpleName.resolveBinding();
					if (simpleNameBinding.isEqualTo(infixVariableBinding))
					{
						variableFoundInExtendedOperands = true;
						break;
					}
				}
			}
			if (left || right || variableFoundInExtendedOperands)
			{
				leftOperandIsVariable = true;
			}
		}
		return leftOperandIsVariable;
	}
	
	private static boolean isVariableRightOperand(SimpleName variable, InfixExpression infixExpression)
	{
		boolean rightOperandIsVariable     = false;
		//Expression leftOperand            = infixExpression.getLeftOperand();
		Expression rightOperand           = infixExpression.getRightOperand();
		IBinding infixVariableBinding     = variable.resolveBinding();
		if (rightOperand instanceof SimpleName)
		{
			SimpleName rightOperandSimpleName = (SimpleName) rightOperand;
			IBinding rightOperandBinding      = rightOperandSimpleName.resolveBinding();
			if (rightOperandBinding.isEqualTo(infixVariableBinding))
			{
				rightOperandIsVariable = true;
			}
		}
		else if (rightOperand instanceof InfixExpression)
		{
			InfixExpression infixRightOperand = (InfixExpression) rightOperand;
			boolean left = isVariableLeftOperand(variable, infixRightOperand);
			boolean right = isVariableRightOperand(variable, infixRightOperand);
			List<Expression> extendedOperands = infixRightOperand.extendedOperands();
			boolean variableFoundInExtendedOperands = false;
			for (Expression expression : extendedOperands)
			{
				if (expression instanceof SimpleName)
				{
					SimpleName simpleName = (SimpleName) expression;
					IBinding simpleNameBinding = simpleName.resolveBinding();
					if (simpleNameBinding.isEqualTo(infixVariableBinding))
					{
						variableFoundInExtendedOperands = true;
						break;
					}
				}
			}
			if (left || right || variableFoundInExtendedOperands)
			{
				rightOperandIsVariable = true;
			}
		}
		return rightOperandIsVariable;
	}
	
	public static List<Statement> unBlock(List<Statement> statements)
	{
		List<Statement> returnList = new ArrayList<Statement>();
		for (Statement currentStatement : statements)
		{
			if (currentStatement instanceof Block)
			{
				List<Statement> subList = ((Block)currentStatement).statements();
				returnList.addAll(unBlock(subList));
			}
			else if (currentStatement instanceof TryStatement)
			{
				List<Statement> subList = ((TryStatement)currentStatement).getBody().statements();
				returnList.addAll(unBlock(subList));
			}
			else
			{
				returnList.add(currentStatement);
			}
		}
		return returnList;
	}
	
	// this method finds the first variable to be initialized (if any) using the control variable to access the data structure it is traversing (if any)
	public static SimpleName getVariableInitializedUsingControlVariable(ControlVariable controlVariable, Statement conditionalLoopBody)
	{
		SimpleName initializedVariableName                                 = null;
		List<ASTNode> variableDeclarationsAndAssignmentsContainingVariable = getVariableDeclarationsAndAssignmentsContainingAccessUsingVariable(conditionalLoopBody, controlVariable);
		// find the node in variableDeclarationsAndAssignmentsContainingVariable that has the smallest start position, compare new variable created to the enhancedForVariable and then return it
		if (variableDeclarationsAndAssignmentsContainingVariable.size() > 0)
		{
			Collections.sort(variableDeclarationsAndAssignmentsContainingVariable, new EarliestStartPositionComparator());
			ASTNode nodeContainingVariable = variableDeclarationsAndAssignmentsContainingVariable.get(0);
			if (nodeContainingVariable instanceof VariableDeclaration)
			{
				initializedVariableName = ((VariableDeclaration)nodeContainingVariable).getName();
			}
			else if (nodeContainingVariable instanceof Assignment && ((Assignment)nodeContainingVariable).getLeftHandSide() instanceof SimpleName)
			{
				initializedVariableName = (SimpleName)((Assignment)nodeContainingVariable).getLeftHandSide();
			}
		}
		return initializedVariableName;
	}
	
	public static List<ASTNode> getVariableDeclarationsAndAssignmentsContainingAccessUsingVariable(Statement body, ControlVariable variable)
	{
		StatementExtractor statementExtractor = new StatementExtractor();
		ExpressionExtractor expressionExtractor = new ExpressionExtractor();
		ArrayList<ASTNode> returnList = new ArrayList<ASTNode>();
		List<Statement> variableDeclarationStatements = statementExtractor.getVariableDeclarationStatements(body);
		List<Expression> assignments = expressionExtractor.getAssignments(body);
		for (Statement currentStatement : variableDeclarationStatements)
		{
			List<VariableDeclarationFragment> fragments = ((VariableDeclarationStatement)currentStatement).fragments();
			for (VariableDeclarationFragment fragment : fragments)
			{
				Expression initializer = fragment.getInitializer();
				if (isAccessUsingVariable(initializer, variable))
				{
					returnList.add(fragment);
				}
			}
		}
		for (Expression currentExpression : assignments)
		{
			Assignment currentAssignment = (Assignment)currentExpression;
			Expression rightHandSide = currentAssignment.getRightHandSide();
			if (isAccessUsingVariable(rightHandSide, variable))
			{
				returnList.add(currentAssignment);
			}
		}
		List<Expression> methodInvocations = expressionExtractor.getMethodInvocations(body);
		for (Expression expression : methodInvocations)
		{
			if (expression instanceof MethodInvocation)
			{
				MethodInvocation methodInvocation = (MethodInvocation)expression;
				Expression methodInvocationExpression = methodInvocation.getExpression();
				if(methodInvocationExpression != null)
				{
					if (isAccessUsingVariable(methodInvocationExpression, variable))
					{
						returnList.add(methodInvocation);
					}
				}
			}
		}
		return returnList;
	}
	
	private static boolean isAccessUsingVariable(Expression expression, ControlVariable controlVariable)
	{
		List<SimpleName> variableOccurrences = getOccurrencesOfSimpleName(expression, controlVariable.getVariable());
		Expression controlVariableDataStructure = controlVariable.getDataStructureExpression();
		if (variableOccurrences.size() == 1)
		{
			SimpleName variableOccurrence = variableOccurrences.get(0);
			ASTNode firstParent = variableOccurrence.getParent();
			ASTNode secondParent = variableOccurrence.getParent().getParent();
			if (firstParent != null && secondParent != null)
			{
				// if expression is an array access
				if (expression instanceof ArrayAccess)
				{
					ArrayAccess arrayAccess = (ArrayAccess)expression;
					Expression array = arrayAccess.getArray();
					if ((firstParent.equals(arrayAccess) || (firstParent instanceof PostfixExpression && secondParent.equals(arrayAccess))))
					{
						if (array instanceof Name  && controlVariableDataStructure instanceof Name)
						{
							Name controlVariableDataStructureName = (Name)controlVariableDataStructure;
							return ((Name)array).resolveBinding().isEqualTo(controlVariableDataStructureName.resolveBinding());
						}
						else if (array instanceof MethodInvocation  && controlVariableDataStructure instanceof MethodInvocation)
						{
							MethodInvocation controlVariableDataStructureMethodInvocation = (MethodInvocation)controlVariableDataStructure;
							return ((MethodInvocation)array).resolveMethodBinding().isEqualTo(controlVariableDataStructureMethodInvocation.resolveMethodBinding());
						}
					}
				}
				// if expression is a method invocation
				else if (expression instanceof MethodInvocation)
				{
					MethodInvocation methodInvocation                 = (MethodInvocation)expression;
					IMethodBinding methodBinding                      = methodInvocation.resolveMethodBinding().getMethodDeclaration();
					AbstractLoopBindingInformation bindingInformation = AbstractLoopBindingInformation.getInstance();
					if (methodInvocation.getExpression() != null)
					{
						// if the variable is the expression of the method (ex: variable is an iterator)
						if (methodInvocation.getExpression().equals(variableOccurrence))
						{
							return bindingInformation.updateMethodValuesContains(methodBinding.getKey());
						}
						// if the variable is an argument of the method OR (the first parent is a postfix expression AND an argument of the method)
						else if (isExpressionAnArgument(variableOccurrence, methodInvocation) || (firstParent instanceof PostfixExpression && isExpressionAnArgument((PostfixExpression)firstParent, methodInvocation)))
						{
							if (bindingInformation.dataStructureAccessMethodsContains(methodBinding.getKey()))
							{
								// check that the expression is the variables traversed data structure
								if (methodInvocation.getExpression() instanceof Name && controlVariableDataStructure instanceof Name)
								{
									Name methodExpressionName = (Name)methodInvocation.getExpression();
									Name controlVariableDataStructureName = (Name)controlVariableDataStructure;
									return methodExpressionName.resolveBinding().isEqualTo(controlVariableDataStructureName.resolveBinding());
								}
								else if (methodInvocation.getExpression() instanceof MethodInvocation && controlVariableDataStructure instanceof MethodInvocation)
								{
									MethodInvocation methodExpressionMethodInvocation = (MethodInvocation)methodInvocation.getExpression();
									MethodInvocation controlVariableDataStructureMethodInvocation = (MethodInvocation)controlVariableDataStructure;
									return methodExpressionMethodInvocation.resolveMethodBinding().isEqualTo(controlVariableDataStructureMethodInvocation.resolveMethodBinding());
								}
							}
						}
					}
				}
			}
		}
		return false;
	}
	
	private static List<SimpleName> getOccurrencesOfSimpleName(Expression expression, SimpleName simpleName)
	{
		List<SimpleName> returnList = new ArrayList<SimpleName>();
		ExpressionExtractor expressionExtractor = new ExpressionExtractor();
		List<Expression> simpleNames = expressionExtractor.getVariableInstructions(expression);
		for (Expression currentExpression : simpleNames)
		{
			SimpleName currentSimpleName = (SimpleName)currentExpression;
			IBinding currentSimpleNameBinding = currentSimpleName.resolveBinding();
			if (currentSimpleNameBinding != null && currentSimpleNameBinding.isEqualTo(simpleName.resolveBinding()))
			{
				returnList.add(currentSimpleName);
			}
		}
		return returnList;
	}
	
	private static boolean isExpressionAnArgument(Expression expression, MethodInvocation methodInvocation)
	{
		List<Expression> arguments = methodInvocation.arguments();
		for (Expression currentArgument : arguments)
		{
			Expression unparenthesizedArgument = AbstractControlStructureUtilities.unparenthesize(currentArgument);
			if (currentArgument.equals(expression) || unparenthesizedArgument.equals(expression))
			{
				return true;
			}
		}
		return false;
	}
}