/*******************************************************************************
 * Copyright (c) 2000, 2010 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:
 *     IBM Corporation - initial API and implementation
 *     Benjamin Muskalla <bmuskalla@eclipsesource.com> - [extract method] Does not replace similar code in parent class of anonymous class - https://bugs.eclipse.org/bugs/show_bug.cgi?id=160853
 *     Benjamin Muskalla <bmuskalla@eclipsesource.com> - [extract method] Extract method and continue https://bugs.eclipse.org/bugs/show_bug.cgi?id=48056
 *     Benjamin Muskalla <bmuskalla@eclipsesource.com> - [extract method] should declare method static if extracted from anonymous in static method - https://bugs.eclipse.org/bugs/show_bug.cgi?id=152004
 *******************************************************************************/
package org.eclipse.dltk.internal.javascript.corext.refactoring.code;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.manipulation.RefactoringChecks;
import org.eclipse.dltk.core.manipulation.SourceModuleChange;
import org.eclipse.dltk.internal.corext.refactoring.ScriptRefactoringDescriptor;
import org.eclipse.dltk.internal.corext.refactoring.util.ResourceUtil;
import org.eclipse.dltk.internal.javascript.core.manipulation.Messages;
import org.eclipse.dltk.internal.javascript.corext.refactoring.Checks;
import org.eclipse.dltk.internal.javascript.corext.refactoring.ParameterInfo;
import org.eclipse.dltk.internal.javascript.corext.refactoring.RefactoringCoreMessages;
import org.eclipse.dltk.internal.javascript.corext.refactoring.code.flow.VariableBinding;
import org.eclipse.dltk.internal.javascript.corext.refactoring.util.Selection;
import org.eclipse.dltk.javascript.core.dom.BinaryExpression;
import org.eclipse.dltk.javascript.core.dom.BinaryOperator;
import org.eclipse.dltk.javascript.core.dom.BlockStatement;
import org.eclipse.dltk.javascript.core.dom.CallExpression;
import org.eclipse.dltk.javascript.core.dom.DomFactory;
import org.eclipse.dltk.javascript.core.dom.DomPackage;
import org.eclipse.dltk.javascript.core.dom.Expression;
import org.eclipse.dltk.javascript.core.dom.ExpressionStatement;
import org.eclipse.dltk.javascript.core.dom.FunctionExpression;
import org.eclipse.dltk.javascript.core.dom.Identifier;
import org.eclipse.dltk.javascript.core.dom.Node;
import org.eclipse.dltk.javascript.core.dom.Parameter;
import org.eclipse.dltk.javascript.core.dom.ReturnStatement;
import org.eclipse.dltk.javascript.core.dom.Source;
import org.eclipse.dltk.javascript.core.dom.Statement;
import org.eclipse.dltk.javascript.core.dom.VariableDeclaration;
import org.eclipse.dltk.javascript.core.dom.VariableReference;
import org.eclipse.dltk.javascript.core.dom.VariableStatement;
import org.eclipse.dltk.javascript.core.dom.rewrite.ASTConverter;
import org.eclipse.dltk.javascript.core.dom.rewrite.Generator;
import org.eclipse.dltk.javascript.core.dom.rewrite.RewriteAnalyzer;
import org.eclipse.dltk.javascript.core.dom.rewrite.VariableLookup;
import org.eclipse.dltk.javascript.core.refactoring.descriptors.ExtractMethodDescriptor;
import org.eclipse.dltk.javascript.parser.JavaScriptParserUtil;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.change.ChangeDescription;
import org.eclipse.emf.ecore.change.util.ChangeRecorder;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringChangeDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.TextFileChange;
import org.eclipse.ltk.core.refactoring.participants.ResourceChangeChecker;
import org.eclipse.text.edits.InsertEdit;
import org.eclipse.text.edits.TextEdit;

/**
 * Extracts a method in a compilation unit based on a text selection range.
 */
public class ExtractMethodRefactoring extends Refactoring {

	//private static final String ATTRIBUTE_VISIBILITY= "visibility"; //$NON-NLS-1$
	private static final String ATTRIBUTE_DESTINATION= "destination"; //$NON-NLS-1$
	/*private static final String ATTRIBUTE_COMMENTS= "comments"; //$NON-NLS-1$
	private static final String ATTRIBUTE_REPLACE= "replace"; //$NON-NLS-1$
	private static final String ATTRIBUTE_EXCEPTIONS= "exceptions"; //$NON-NLS-1$*/

	private ISourceModule fCUnit;
	private String fSource;
	private Source fRoot;
	//private ImportRewrite fImportRewriter;
	private int fSelectionStart;
	private int fSelectionLength;
	/*private AST fAST;
	private ASTRewrite fRewriter;*/
	private ExtractMethodAnalyzer fAnalyzer;
	//private int fVisibility;
	private String fMethodName;
	//private boolean fThrowRuntimeExceptions;
	private List<ParameterInfo> fParameterInfos;
	private Set<String> fUsedNames;
	/*private boolean fGenerateScriptdoc;
	private boolean fReplaceDuplicates;
	private SnippetFinder.Match[] fDuplicates;*/
	private int fDestinationIndex= 0;
	private Node fDestination;
	private Node[] fDestinations;
	//private LinkedProposalModel fLinkedProposalModel;

	private static final String EMPTY= ""; //$NON-NLS-1$

	/*private static final String KEY_TYPE= "type"; //$NON-NLS-1$
	private static final String KEY_NAME= "name"; //$NON-NLS-1$

	private static class UsedNamesCollector extends ASTVisitor {
		private Set result= new HashSet();
		private Set fIgnore= new HashSet();
		public static Set perform(ASTNode[] nodes) {
			UsedNamesCollector collector= new UsedNamesCollector();
			for (int i= 0; i < nodes.length; i++) {
				nodes[i].accept(collector);
			}
			return collector.result;
		}
		public boolean visit(FieldAccess node) {
			Expression exp= node.getExpression();
			if (exp != null)
				fIgnore.add(node.getName());
			return true;
		}
		public void endVisit(FieldAccess node) {
			fIgnore.remove(node.getName());
		}
		public boolean visit(MethodInvocation node) {
			Expression exp= node.getExpression();
			if (exp != null)
				fIgnore.add(node.getName());
			return true;
		}
		public void endVisit(MethodInvocation node) {
			fIgnore.remove(node.getName());
		}
		public boolean visit(QualifiedName node) {
			fIgnore.add(node.getName());
			return true;
		}
		public void endVisit(QualifiedName node) {
			fIgnore.remove(node.getName());
		}
		public boolean visit(SimpleName node) {
			if (!fIgnore.contains(node))
				result.add(node.getIdentifier());
			return true;
		}
		public boolean visit(TypeDeclaration node) {
			return visitType(node);
		}
		public boolean visit(AnnotationTypeDeclaration node) {
			return visitType(node);
		}
		public boolean visit(EnumDeclaration node) {
			return visitType(node);
		}
		private boolean visitType(AbstractTypeDeclaration node) {
			result.add(node.getName().getIdentifier());
			// don't dive into type declaration since they open a new
			// context.
			return false;
		}
	}

	/**
	 * Creates a new extract method refactoring
	 * @param unit the compilation unit, or <code>null</code> if invoked by scripting
	 * @param selectionStart selection start
	 * @param selectionLength selection end
	 */
	public ExtractMethodRefactoring(ISourceModule unit, int selectionStart, int selectionLength) {
		fCUnit= unit;
		fRoot= null;
		fMethodName= "extracted"; //$NON-NLS-1$
		fSelectionStart= selectionStart;
		fSelectionLength= selectionLength;
		//fVisibility= -1;
	}

    /*public ExtractMethodRefactoring(ScriptRefactoringArguments arguments, RefactoringStatus status) {
   		this((ISourceModule) null, 0, 0);
   		RefactoringStatus initializeStatus= initialize(arguments);
   		status.merge(initializeStatus);
    }

	/**
	 * Creates a new extract method refactoring
	 * @param astRoot the AST root of an AST created from a compilation unit
	 * @param selectionStart start
	 * @param selectionLength length
	 *
	public ExtractMethodRefactoring(Source astRoot, int selectionStart, int selectionLength) {
		this((ISourceModule) astRoot.getTypeRoot(), selectionStart, selectionLength);
		fRoot= astRoot;
	}

	public void setLinkedProposalModel(LinkedProposalModel linkedProposalModel) {
		fLinkedProposalModel= linkedProposalModel;
	}*/

	 public String getName() {
	 	return RefactoringCoreMessages.ExtractMethodRefactoring_name;
	 }

	/**
	 * Checks if the refactoring can be activated. Activation typically means, if a
	 * corresponding menu entry can be added to the UI.
	 *
	 * @param pm a progress monitor to report progress during activation checking.
	 * @return the refactoring status describing the result of the activation check.
	 * @throws CoreException if checking fails
	 */
	public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
		RefactoringStatus result= new RefactoringStatus();
		pm.beginTask("", 100); //$NON-NLS-1$

		if (fSelectionStart < 0 || fSelectionLength == 0) {
			result.addFatalError(RefactoringCoreMessages.ExtractMethodRefactoring_no_set_of_statements);
			return result;
		}

		IFile[] changedFiles= ResourceUtil.getFiles(new ISourceModule[]{fCUnit});
		result.merge(RefactoringChecks.validateModifiesFiles(changedFiles, getValidationContext()));
		if (result.hasFatalError())
			return result;
		result.merge(ResourceChangeChecker.checkFilesToBeChanged(changedFiles, new SubProgressMonitor(pm, 1)));

		if (fRoot == null) {
			fRoot = (Source)ASTConverter.convert(JavaScriptParserUtil.parse(fCUnit));
		}
		//fImportRewriter= StubUtility.createImportRewrite(fRoot, true);

		//fAST= fRoot.getAST();
		fAnalyzer= new ExtractMethodAnalyzer(fCUnit, Selection.createFromStartLength(fSelectionStart, fSelectionLength));
		//fRoot.accept(fAnalyzer);

		result.merge(fAnalyzer.checkInitialConditions(fRoot));
		if (result.hasFatalError())
			return result;
		
		fSource = fCUnit.getSource();
		Node[] nodes = fAnalyzer.getSelectedNodes();
		boolean badSelection = false;
		for(int i=fSelectionStart;i<nodes[0].getBegin();i++)
			if (!Character.isWhitespace(fSource.charAt(i))) badSelection = true; 
		for(int i=nodes[nodes.length-1].getEnd();i<fSelectionStart+fSelectionLength;i++)
			if (!Character.isWhitespace(fSource.charAt(i))) badSelection = true;
		if (badSelection) {
			result.addFatalError(RefactoringCoreMessages.StatementAnalyzer_doesNotCover);
			return result;
		}
		/*if (fVisibility == -1) {
			setVisibility(Modifier.PRIVATE);
		}*/
		initializeParameterInfos();
		initializeUsedNames();
		//initializeDuplicates();
		initializeDestinations();
		return result;
	}

	/**
	 * Sets the method name to be used for the extracted method.
	 *
	 * @param name the new method name.
	 */
	public void setMethodName(String name) {
		fMethodName= name;
	}

	/**
	 * Returns the method name to be used for the extracted method.
	 * @return the method name to be used for the extracted method.
	 *
	public String getMethodName() {
		return fMethodName;
	}

	/**
	 * Sets the visibility of the new method.
	 *
	 * @param visibility the visibility of the new method. Valid values are
	 *  "public", "protected", "", and "private"
	 *
	public void setVisibility(int visibility) {
		fVisibility= visibility;
	}

	/**
	 * Returns the visibility of the new method.
	 *
	 * @return the visibility of the new method
	 *
	public int getVisibility() {
		return fVisibility;
	}

	/**
	 * Returns the parameter infos.
	 * @return a list of parameter infos.
	 */
	public List<ParameterInfo> getParameterInfos() {
		return fParameterInfos;
	}

	/**
	 * Sets whether the new method signature throws runtime exceptions.
	 *
	 * @param throwRuntimeExceptions flag indicating if the new method
	 * 	throws runtime exceptions
	 *
	public void setThrowRuntimeExceptions(boolean throwRuntimeExceptions) {
		fThrowRuntimeExceptions= throwRuntimeExceptions;
	}

	/**
	 * Checks if the new method name is a valid method name. This method doesn't
	 * check if a method with the same name already exists in the hierarchy. This
	 * check is done in <code>checkInput</code> since it is expensive.
	 * @return validation status
	 */
	public RefactoringStatus checkMethodName() {
		return Checks.validateIdentifier(fMethodName);
	}

	public Node[] getDestinations() {
		return fDestinations;
	}

	public void setDestination(int index) {
		fDestination= fDestinations[index];
		fDestinationIndex= index;
	}

	/**
	 * Checks if the parameter names are valid.
	 * @return validation status
	 */
	public RefactoringStatus checkParameterNames() {
		RefactoringStatus result= new RefactoringStatus();
		for (ParameterInfo parameter : fParameterInfos) {
			result.merge(Checks.validateIdentifier(parameter.getNewName()));
			for (ParameterInfo other : fParameterInfos) {
				if (parameter != other && other.getNewName().equals(parameter.getNewName())) {
					result.addError(Messages.format(
						RefactoringCoreMessages.ExtractMethodRefactoring_error_sameParameter,
						//BasicElementLabels.getScriptElementName(other.getNewName())
						other.getNewName()));
					return result;
				}
			}
			if (parameter.isRenamed() && fUsedNames.contains(parameter.getNewName())) {
				result.addError(Messages.format(
					RefactoringCoreMessages.ExtractMethodRefactoring_error_nameInUse,
					//BasicElementLabels.getScriptElementName(parameter.getNewName())
					parameter.getNewName()));
				return result;
			}
		}
		return result;
	}

	/**
	 * Checks if varargs are ordered correctly.
	 * @return validation status
	 *
	public RefactoringStatus checkVarargOrder() {
		for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
			ParameterInfo info= (ParameterInfo)iter.next();
			if (info.isOldVarargs() && iter.hasNext()) {
				return RefactoringStatus.createFatalErrorStatus(Messages.format(
					 RefactoringCoreMessages.ExtractMethodRefactoring_error_vararg_ordering,
					 BasicElementLabels.getScriptElementName(info.getOldName())));
			}
		}
		return new RefactoringStatus();
	}

	/**
	 * Returns the names already in use in the selected statements/expressions.
	 *
	 * @return names already in use.
	 *
	public Set getUsedNames() {
		return fUsedNames;
	}

	/* (non-Scriptdoc)
	 * Method declared in Refactoring
	 */
	public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException {
		pm.beginTask(RefactoringCoreMessages.ExtractMethodRefactoring_checking_new_name, 1);
		pm.subTask(EMPTY);

		RefactoringStatus result= checkMethodName();
		result.merge(checkParameterNames());
		/*result.merge(checkVarargOrder());
		pm.worked(1);
		if (pm.isCanceled())
			throw new OperationCanceledException();

		Node node= fAnalyzer.getEnclosingNode();
		if (node != null) {
			fAnalyzer.checkInput(result, fMethodName);
			pm.worked(1);
		}*/
		pm.done();
		return result;
	}

	/* (non-Scriptdoc)
	 * Method declared in IRefactoring
	 */
	public Change createChange(IProgressMonitor pm) throws CoreException {
		if (fMethodName == null)
			return null;
		pm.beginTask("", 2); //$NON-NLS-1$
		try {
			ChangeRecorder cr = new ChangeRecorder(fRoot);
			Node[] nodes = fAnalyzer.getSelectedNodes();
			boolean isExpr = fAnalyzer.isExpressionSelected();
			// replace method parameter names
			Map<String,String> renamings = new HashMap<String,String>();
			for (ParameterInfo parameter : fParameterInfos)
				if (parameter.isRenamed())
					renamings.put(parameter.getOldName(),parameter.getNewName());
			for (Node node : nodes) {
				List<Identifier> oldNames = VariableLookup.findReferences(node, renamings.keySet());
				for (Identifier ref : oldNames) {
					ref.setName(renamings.get(ref.getName()));
				}
			}			
			// create call
			CallExpression invocation= DomFactory.eINSTANCE.createCallExpression();
			{
				VariableReference ref = DomFactory.eINSTANCE.createVariableReference();
				Identifier id = DomFactory.eINSTANCE.createIdentifier();
				id.setName(fMethodName);
				ref.setVariable(id);
				invocation.setApplicant(ref);
			}
			for (ParameterInfo parameter : fParameterInfos) {
				Identifier name = DomFactory.eINSTANCE.createIdentifier();
				name.setName(parameter.getOldName());
				VariableReference local = DomFactory.eINSTANCE.createVariableReference();
				local.setVariable(name);
				invocation.getArguments().add(local);
			}
			if (isExpr) {
				// replace with call
				EReference ref = nodes[0].eContainmentFeature();
				if (ref.isMany()) {
					EList<Expression> exprList = (EList<Expression>)nodes[0].eContainer().eGet(ref);
					exprList.set(exprList.lastIndexOf(nodes[0]), (Expression)invocation);
				} else {
					nodes[0].eContainer().eSet(ref, invocation);
				}
			} else {
				// create replacement
				Node call;
				int returnKind= fAnalyzer.getReturnKind();
				switch (returnKind) {
				case ExtractMethodAnalyzer.ACCESS_TO_LOCAL:
					VariableBinding binding= fAnalyzer.getReturnLocal();
					if (binding != null) {
						call = createDeclaration(binding, invocation);
					} else {
						BinaryExpression assignment= DomFactory.eINSTANCE.createBinaryExpression();
						assignment.setOperation(BinaryOperator.ASSIGN);
						VariableReference retVar = DomFactory.eINSTANCE.createVariableReference();
						Identifier id = DomFactory.eINSTANCE.createIdentifier();
						id.setName(fAnalyzer.getReturnValue().getName());
						retVar.setVariable(id);
						assignment.setLeft(retVar);
						assignment.setRight(invocation);
						call = assignment;
					}
					break;
				case ExtractMethodAnalyzer.RETURN_STATEMENT_VALUE:
					ReturnStatement rs=DomFactory.eINSTANCE.createReturnStatement();
					rs.setExpression(invocation);
					call = rs;
					break;
				default:
					call = invocation;
				}
				if (call instanceof Expression) {
					ExpressionStatement stmt = DomFactory.eINSTANCE.createExpressionStatement();
					stmt.setExpression((Expression)call);
					call = stmt;
				}
				List<Statement> callNodes= new ArrayList<Statement>(2);
				callNodes.add((Statement)call);
				if (returnKind == ExtractMethodAnalyzer.RETURN_STATEMENT_VOID && !fAnalyzer.isLastStatementSelected()) {
					callNodes.add(DomFactory.eINSTANCE.createReturnStatement());
				}
				for (VariableBinding local : fAnalyzer.getCallerLocals())
					callNodes.add(createDeclaration(local, null));
				// replace with call
				EReference ref = nodes[0].eContainmentFeature();
				if (ref.isMany()) {
					EList<Statement> list = (EList<Statement>)nodes[0].eContainer().eGet(ref);
					int index = list.lastIndexOf(nodes[0]);
					for(int i=nodes.length-1;i>=0;i--)
						list.remove(index+i);
					list.addAll(index, callNodes);
				} else if (callNodes.size() == 1) {
					nodes[0].eContainer().eSet(ref, callNodes.get(0));
				} else {
					BlockStatement block = DomFactory.eINSTANCE.createBlockStatement();
					block.getStatements().addAll(callNodes);
					nodes[0].eContainer().eSet(ref, block);
				}				
			}
			// create declaration
			FunctionExpression mm = createNewMethodDeclaration();
			List<Statement> statements = mm.getBody().getStatements();
			VariableBinding[] methodLocals= fAnalyzer.getMethodLocals();
			for (int i= 0; i < methodLocals.length; i++) {
				if (methodLocals[i] != null)
					statements.add(createDeclaration(methodLocals[i],null));
			}
			if (isExpr) {
				ReturnStatement rs = DomFactory.eINSTANCE.createReturnStatement();
				rs.setExpression((Expression)nodes[0]);
				statements.add(rs);
			} else {
				for(Node node : nodes) 
					statements.add((Statement)node);
				VariableBinding returnValue= fAnalyzer.getReturnValue();
				if (returnValue != null) {
					ReturnStatement rs = DomFactory.eINSTANCE.createReturnStatement();
					VariableReference ret = DomFactory.eINSTANCE.createVariableReference();
					Identifier rid = DomFactory.eINSTANCE.createIdentifier();
					String name = returnValue.getName();
					if (renamings.containsKey(name))
						name = renamings.get(name);
					rid.setName(name);
					ret.setVariable(rid);
					rs.setExpression(ret);
					statements.add(rs);
				}
			}
			// add declaration
			final ExpressionStatement stmt = DomFactory.eINSTANCE.createExpressionStatement();
			stmt.setExpression(mm);
			Node enclosing = fDestination;
			EReference ref = enclosing.eContainmentFeature();
			assert ref.isMany();
			EList<Statement> list = (EList<Statement>)enclosing.eContainer().eGet(ref);
			list.add(list.lastIndexOf(enclosing)+1,stmt);
			// TODO replace branches
			ChangeDescription cd = cr.endRecording();
			RewriteAnalyzer ra = new RewriteAnalyzer(cd, fSource) {
				@Override
				protected void addEdit(TextEdit edit, Node node) {
					if (node == stmt) {
						edit = new InsertEdit(edit.getOffset(),
								lineDelimiter+((InsertEdit)edit).getText());
					}
					super.addEdit(edit, node);
				}
			};
			SourceModuleChange result= new SourceModuleChange(RefactoringCoreMessages.ExtractMethodRefactoring_change_name, fCUnit);
			ra.rewrite(fRoot);
			result.setSaveMode(TextFileChange.KEEP_SAVE_STATE);
			result.setDescriptor(new RefactoringChangeDescriptor(getRefactoringDescriptor()));
			result.setEdit(ra.getEdit());
			cd.apply();
			return result;
		} finally {
			pm.done();
		}
	}

	/*private void replaceBranches(final SourceModuleChange result) {
		ASTNode[] selectedNodes= fAnalyzer.getSelectedNodes();
		for (int i= 0; i < selectedNodes.length; i++) {
			ASTNode astNode= selectedNodes[i];
			astNode.accept(new ASTVisitor() {
				private LinkedList fOpenLoopLabels= new LinkedList();

				private void registerLoopLabel(Statement node) {
					String identifier;
					if (node.getParent() instanceof LabeledStatement) {
						LabeledStatement labeledStatement= (LabeledStatement)node.getParent();
						identifier= labeledStatement.getLabel().getIdentifier();
					} else {
						identifier= null;
					}
					fOpenLoopLabels.add(identifier);
				}
				
				public boolean visit(ForStatement node) {
					registerLoopLabel(node);
					return super.visit(node);
				}

				public void endVisit(ForStatement node) {
					fOpenLoopLabels.removeLast();
				}

				public boolean visit(WhileStatement node) {
					registerLoopLabel(node);
					return super.visit(node);
				}

				public void endVisit(WhileStatement node) {
					fOpenLoopLabels.removeLast();
				}

				public boolean visit(EnhancedForStatement node) {
					registerLoopLabel(node);
					return super.visit(node);
				}

				public void endVisit(EnhancedForStatement node) {
					fOpenLoopLabels.removeLast();
				}

				public boolean visit(DoStatement node) {
					registerLoopLabel(node);
					return super.visit(node);
				}

				public void endVisit(DoStatement node) {
					fOpenLoopLabels.removeLast();
				}

				public void endVisit(ContinueStatement node) {
					final SimpleName label= node.getLabel();
					if (fOpenLoopLabels.isEmpty() || (label != null && !fOpenLoopLabels.contains(label.getIdentifier()))) {
						TextEditGroup description= new TextEditGroup(RefactoringCoreMessages.ExtractMethodRefactoring_replace_continue);
						result.addTextEditGroup(description);

						ReturnStatement rs= fAST.newReturnStatement();
						IVariableBinding returnValue= fAnalyzer.getReturnValue();
						if (returnValue != null) {
							rs.setExpression(fAST.newSimpleName(getName(returnValue)));
						}

						fRewriter.replace(node, rs, description);
					}
				}
			});
		}
	}*/

	private ExtractMethodDescriptor getRefactoringDescriptor() {
		final Map arguments= new HashMap();
		String project= null;
		IScriptProject ScriptProject= fCUnit.getScriptProject();
		if (ScriptProject != null)
			project= ScriptProject.getElementName();
		/*ITypeBinding type= null;
		if (fDestination instanceof AbstractTypeDeclaration) {
			final AbstractTypeDeclaration decl= (AbstractTypeDeclaration) fDestination;
			type= decl.resolveBinding();
		} else if (fDestination instanceof AnonymousClassDeclaration) {
			final AnonymousClassDeclaration decl= (AnonymousClassDeclaration) fDestination;
			type= decl.resolveBinding();
		}
		IMethodBinding method= null;
		final Node enclosing= fAnalyzer.getEnclosingNode();
		if (enclosing instanceof MethodDeclaration) {
			final MethodDeclaration node= (MethodDeclaration) enclosing;
			method= node.resolveBinding();
		}*/
		final int flags= RefactoringDescriptor.STRUCTURAL_CHANGE | ScriptRefactoringDescriptor.ARCHIVE_REFACTORABLE | ScriptRefactoringDescriptor.ARCHIVE_IMPORTABLE;
		final String description= Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_descriptor_description_short, fMethodName);
		//final String label= method != null ? BindingLabelProvider.getBindingLabel(method, ScriptElementLabels.ALL_FULLY_QUALIFIED) : '{' + ScriptElementLabels.ELLIPSIS_STRING + '}';
		//final String header= Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_descriptor_description, new String[] { BasicElementLabels.getScriptElementName(getSignature()), label, BindingLabelProvider.getBindingLabel(type, ScriptElementLabels.ALL_FULLY_QUALIFIED)});
		//final ScriptRefactoringDescriptorComment comment= new ScriptRefactoringDescriptorComment(project, this, header);
		//comment.addSetting(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_name_pattern, BasicElementLabels.getScriptElementName(fMethodName)));
		//comment.addSetting(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_destination_pattern, BindingLabelProvider.getBindingLabel(type, ScriptElementLabels.ALL_FULLY_QUALIFIED)));
		//String visibility= JdtFlags.getVisibilityString(fVisibility);
		//if ("".equals(visibility)) //$NON-NLS-1$
		//	visibility= RefactoringCoreMessages.ExtractMethodRefactoring_default_visibility;
		//comment.addSetting(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_visibility_pattern, visibility));
		//if (fThrowRuntimeExceptions)
		//	comment.addSetting(RefactoringCoreMessages.ExtractMethodRefactoring_declare_thrown_exceptions);
		//if (fReplaceDuplicates)
		//	comment.addSetting(RefactoringCoreMessages.ExtractMethodRefactoring_replace_occurrences);
		//if (fGenerateScriptdoc)
		//	comment.addSetting(RefactoringCoreMessages.ExtractMethodRefactoring_generate_comment);
		final ExtractMethodDescriptor descriptor= new ExtractMethodDescriptor(project, description, ""/*comment.asString()*/, arguments, flags);
		arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_INPUT, ScriptRefactoringDescriptor.elementToHandle(project, fCUnit));
		arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_NAME, fMethodName);
		arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_SELECTION, new Integer(fSelectionStart).toString() + " " + new Integer(fSelectionLength).toString()); //$NON-NLS-1$
		//arguments.put(ATTRIBUTE_VISIBILITY, new Integer(fVisibility).toString());
		arguments.put(ATTRIBUTE_DESTINATION, new Integer(fDestinationIndex).toString());
		//arguments.put(ATTRIBUTE_EXCEPTIONS, Boolean.valueOf(fThrowRuntimeExceptions).toString());
		//arguments.put(ATTRIBUTE_COMMENTS, Boolean.valueOf(fGenerateScriptdoc).toString());
		//arguments.put(ATTRIBUTE_REPLACE, Boolean.valueOf(fReplaceDuplicates).toString());
		return descriptor;
	}

	/**
	 * Returns the signature of the new method.
	 *
	 * @return the signature of the extracted method
	 */
	public String getSignature() {
		return getSignature(fMethodName);
	}

	/**
	 * Returns the signature of the new method.
	 *
	 * @param methodName the method name used for the new method
	 * @return the signature of the extracted method
	 */
	public String getSignature(String methodName) {
		FunctionExpression methodDecl= createNewMethodDeclaration();
		String str = new Generator(null,"",0,"").generate(methodDecl).toString();
		return str.substring(0, str.indexOf('{')-1);
	}

	/*
	 * Returns the number of duplicate code snippets found.
	 *
	 * @return the number of duplicate code fragments
	 *
	public int getNumberOfDuplicates() {
		if (fDuplicates == null)
			return 0;
		int result=0;
		for (int i= 0; i < fDuplicates.length; i++) {
			if (!fDuplicates[i].isMethodBody())
				result++;
		}
		return result;
	}

	public boolean getReplaceDuplicates() {
		return fReplaceDuplicates;
	}

	public void setReplaceDuplicates(boolean replace) {
		fReplaceDuplicates= replace;
	}

	public void setGenerateScriptdoc(boolean generate) {
		fGenerateScriptdoc= generate;
	}

	public boolean getGenerateScriptdoc() {
		return fGenerateScriptdoc;
	}*/

	//---- Helper methods ------------------------------------------------------------------------

	private void initializeParameterInfos() {
		VariableBinding[] arguments= fAnalyzer.getArguments();
		fParameterInfos= new ArrayList<ParameterInfo>(arguments.length);
		for (int i= 0; i < arguments.length; i++) {
			String argument = arguments[i].getName();
			String type = arguments[i].getTypeName();
			if (type == null)
				type = "";
			fParameterInfos.add(new ParameterInfo(type, argument, i));
		}
	}

	private void initializeUsedNames() {
		// TODO might need more thinking
		fUsedNames = VariableLookup.getVisibleNames(fAnalyzer.getSelectedNodes()[0]);
		//fUsedNames= UsedNamesCollector.perform(fAnalyzer.getSelectedNodes());
		for (ParameterInfo parameter : fParameterInfos) {
			fUsedNames.remove(parameter.getOldName());
		}
	}

	/*private void initializeDuplicates() {
		ASTNode start= fAnalyzer.getEnclosingBodyDeclaration();
		while (!(start instanceof AbstractTypeDeclaration)) {
			start= start.getParent();
		}

		fDuplicates= SnippetFinder.perform(start, fAnalyzer.getSelectedNodes());
		fReplaceDuplicates= fDuplicates.length > 0 && ! fAnalyzer.isLiteralNodeSelected();
	}*/

	private void initializeDestinations() {
		List<Node> result= new ArrayList<Node>();
		Node node= fAnalyzer.getEnclosingNode();
		Node parent = node == null ? null : (Node)node.eContainer();
		Node grandparent = parent == null ? null : (Node)parent.eContainer();
		if (node instanceof Source) {
			Node cur = fAnalyzer.getSelectedNodes()[0];
			while (cur.eContainer() != node)
				cur = (Node)cur.eContainer();
			result.add(cur);
		} else {
			while (node != null) {
				if (parent instanceof Source) break;
				boolean stop = false;
				switch(grandparent.eClass().getClassifierID()) {
				case DomPackage.GETTER_ASSIGNMENT:
				case DomPackage.SETTER_ASSIGNMENT:
				case DomPackage.FUNCTION_EXPRESSION:
					stop = true;
				}
				if (stop) break;
				node = parent;
				parent = grandparent;
				grandparent = parent == null ? null : (Node)parent.eContainer();
			}
			if (node != null) result.add(node);
		}
		// TODO understand what we need here or we can just move manually after refactoring
		/*if (decl instanceof FunctionExpression) {
			//ITypeBinding binding= ASTNodes.getEnclosingType(current);
			Node next= getNextParent(current);
			while (next != null && binding != null && binding.isNested()) {
				result.add(next);
				current= next;
				binding= ASTNodes.getEnclosingType(current);
				next= getNextParent(next);
			}
		}*/
		fDestinations= (Node[])result.toArray(new Node[result.size()]);
		fDestination= fDestinations[fDestinationIndex];
	}

	private FunctionExpression createNewMethodDeclaration() {
		FunctionExpression result= DomFactory.eINSTANCE.createFunctionExpression();

		//int modifiers= fVisibility;
		/*Node enclosingBodyDeclaration= fAnalyzer.getEnclosingNode();
		while (enclosingBodyDeclaration != null && enclosingBodyDeclaration.eContainer() != fDestination) {
			enclosingBodyDeclaration= (Node)enclosingBodyDeclaration.eContainer();
		}
		if (enclosingBodyDeclaration instanceof BodyDeclaration) { // should always be the case
			int enclosingModifiers= ((BodyDeclaration)enclosingBodyDeclaration).getModifiers();
			boolean shouldBeStatic= Modifier.isStatic(enclosingModifiers) || fAnalyzer.getForceStatic();
			if (shouldBeStatic) {
				modifiers|= Modifier.STATIC;
			}
		}

		ITypeBinding[] typeVariables= computeLocalTypeVariables();
		List typeParameters= result.typeParameters();
		for (int i= 0; i < typeVariables.length; i++) {
			TypeParameter parameter= fAST.newTypeParameter();
			parameter.setName(fAST.newSimpleName(typeVariables[i].getName()));
			typeParameters.add(parameter);
		}

		result.modifiers().addAll(ASTNodeFactory.newModifiers(fAST, modifiers));
		result.setReturnType2((Type)ASTNode.copySubtree(fAST, fAnalyzer.getReturnType()));*/
		if (fAnalyzer.getReturnTypeName() != null) {
//			Type type = DomFactory.eINSTANCE.createType();
//			type.setName(fAnalyzer.getReturnTypeName());
//			result.setReturnType(type);
		}
		Identifier id = DomFactory.eINSTANCE.createIdentifier();
		id.setName(fMethodName);
		result.setIdentifier(id);

		List<Parameter> parameters= result.getParameters();
		for (int i= 0; i < fParameterInfos.size(); i++) {
			ParameterInfo info= (ParameterInfo)fParameterInfos.get(i);
			Parameter parameter= DomFactory.eINSTANCE.createParameter();
			Identifier prmName = DomFactory.eINSTANCE.createIdentifier();
			prmName.setName(info.getNewName());
			parameter.setName(prmName);
			if (!"".equals(info.getNewTypeName())) { //$NON-NLS-1
//				Type type = DomFactory.eINSTANCE.createType();
//				type.setName(info.getNewTypeName());
//				parameter.setType(type);
			}
			parameters.add(parameter);
		}

		/*List exceptions= result.thrownExceptions();
		ITypeBinding[] exceptionTypes= fAnalyzer.getExceptions(fThrowRuntimeExceptions);
		ImportRewriteContext context= new ContextSensitiveImportRewriteContext(enclosingBodyDeclaration, fImportRewriter);
		for (int i= 0; i < exceptionTypes.length; i++) {
			ITypeBinding exceptionType= exceptionTypes[i];
			exceptions.add(ASTNodeFactory.newName(fAST, fImportRewriter.addImport(exceptionType, context)));
		}*/
		result.setBody(DomFactory.eINSTANCE.createBlockStatement());
		return result;
	}

	/*private ITypeBinding[] computeLocalTypeVariables() {
		List result= new ArrayList(Arrays.asList(fAnalyzer.getTypeVariables()));
		for (int i= 0; i < fParameterInfos.size(); i++) {
			ParameterInfo info= (ParameterInfo)fParameterInfos.get(i);
			processVariable(result, info.getOldBinding());
		}
		IVariableBinding[] methodLocals= fAnalyzer.getMethodLocals();
		for (int i= 0; i < methodLocals.length; i++) {
			processVariable(result, methodLocals[i]);
		}
		return (ITypeBinding[])result.toArray(new ITypeBinding[result.size()]);
	}

	private void processVariable(List result, IVariableBinding variable) {
		if (variable == null)
			return;
		ITypeBinding binding= variable.getType();
		if (binding != null && binding.isParameterizedType()) {
			ITypeBinding[] typeArgs= binding.getTypeArguments();
			for (int args= 0; args < typeArgs.length; args++) {
				ITypeBinding arg= typeArgs[args];
				if (arg.isTypeVariable() && !result.contains(arg)) {
					ASTNode decl= fRoot.findDeclaringNode(arg);
					if (decl != null && decl.getParent() instanceof MethodDeclaration) {
						result.add(arg);
					}
				}
			}
		}
	}*/

	/*private String getName(IVariableBinding binding) {
		for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
			ParameterInfo info= (ParameterInfo)iter.next();
			if (Bindings.equals(binding, info.getOldBinding())) {
				return info.getNewName();
			}
		}
		return binding.getName();
	}

	private VariableDeclaration getVariableDeclaration(ParameterInfo parameter) {
		return ASTNodes.findVariableDeclaration(parameter.getOldBinding(), fAnalyzer.getEnclosingBodyDeclaration());
	}*/

	private VariableStatement createDeclaration(VariableBinding name, Expression initializer) {
		Identifier id = DomFactory.eINSTANCE.createIdentifier();
		id.setName(name.getName());
		VariableDeclaration decl = DomFactory.eINSTANCE.createVariableDeclaration();
		decl.setIdentifier(id);
		if (name.getTypeName() != null) {
//			Type type = DomFactory.eINSTANCE.createType();
//			type.setName(name.getTypeName());
		}
		if (initializer != null)
			decl.setInitializer(initializer);
		VariableStatement result = DomFactory.eINSTANCE.createVariableStatement();
		result.getDeclarations().add(decl);
		return result;
	}

	/*public ISourceModule getSource() {
		return fCUnit;
	}

	private RefactoringStatus initialize(ScriptRefactoringArguments arguments) {
		final String selection= arguments.getAttribute(ScriptRefactoringDescriptorUtil.ATTRIBUTE_SELECTION);
		if (selection == null)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ScriptRefactoringDescriptorUtil.ATTRIBUTE_SELECTION));

		int offset= -1;
		int length= -1;
		final StringTokenizer tokenizer= new StringTokenizer(selection);
		if (tokenizer.hasMoreTokens())
			offset= Integer.valueOf(tokenizer.nextToken()).intValue();
		if (tokenizer.hasMoreTokens())
			length= Integer.valueOf(tokenizer.nextToken()).intValue();
		if (offset < 0 || length < 0)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_illegal_argument, new Object[] { selection, ScriptRefactoringDescriptorUtil.ATTRIBUTE_SELECTION}));

		fSelectionStart= offset;
		fSelectionLength= length;

		final String handle= arguments.getAttribute(ScriptRefactoringDescriptorUtil.ATTRIBUTE_INPUT);
		if (handle == null)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ScriptRefactoringDescriptorUtil.ATTRIBUTE_INPUT));

		IScriptElement element= ScriptRefactoringDescriptorUtil.handleToElement(arguments.getProject(), handle, false);
		if (element == null || !element.exists() || element.getElementType() != IScriptElement.COMPILATION_UNIT)
			return ScriptRefactoringDescriptorUtil.createInputFatalStatus(element, getName(), IScriptRefactorings.EXTRACT_METHOD);

		fCUnit= (ISourceModule) element;
		final String visibility= arguments.getAttribute(ATTRIBUTE_VISIBILITY);
		if (visibility != null && visibility.length() != 0) {
			int flag= 0;
			try {
				flag= Integer.parseInt(visibility);
			} catch (NumberFormatException exception) {
				return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_VISIBILITY));
			}
			fVisibility= flag;
		}
		final String name= arguments.getAttribute(ScriptRefactoringDescriptorUtil.ATTRIBUTE_NAME);
		if (name == null || name.length() == 0)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ScriptRefactoringDescriptorUtil.ATTRIBUTE_NAME));

		fMethodName= name;

		final String destination= arguments.getAttribute(ATTRIBUTE_DESTINATION);
		if (destination != null && destination.length() == 0) {
			int index= 0;
			try {
				index= Integer.parseInt(destination);
			} catch (NumberFormatException exception) {
				return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_DESTINATION));
			}
			fDestinationIndex= index;
		}
		final String replace= arguments.getAttribute(ATTRIBUTE_REPLACE);
		if (replace == null)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_REPLACE));

		fReplaceDuplicates= Boolean.valueOf(replace).booleanValue();

		final String comments= arguments.getAttribute(ATTRIBUTE_COMMENTS);
		if (comments == null)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_COMMENTS));

		fGenerateScriptdoc= Boolean.valueOf(comments).booleanValue();

		final String exceptions= arguments.getAttribute(ATTRIBUTE_EXCEPTIONS);
		if (exceptions == null)
			return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_EXCEPTIONS));

		fThrowRuntimeExceptions= Boolean.valueOf(exceptions).booleanValue();

		return new RefactoringStatus();
	}*/
}