/*******************************************************************************
 * Copyright (c) 2000, 2008 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
 *     Dmitry Stalnov (dstalnov@fusionone.com) - contributed fixes for:
 *       o inline call that is used in a field initializer
 *         (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38137)
 *       o Allow 'this' constructor to be inlined
 *         (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38093)
 *******************************************************************************/
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 org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.dltk.core.IMethod;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ModelException;
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.changes.DynamicValidationRefactoringChange;
import org.eclipse.dltk.internal.corext.refactoring.util.TextChangeManager;
import org.eclipse.dltk.internal.javascript.core.manipulation.JavascriptManipulationPlugin;
import org.eclipse.dltk.internal.javascript.core.manipulation.Messages;
import org.eclipse.dltk.internal.javascript.corext.refactoring.RefactoringCoreMessages;
import org.eclipse.dltk.javascript.core.dom.CallExpression;
import org.eclipse.dltk.javascript.core.dom.FunctionExpression;
import org.eclipse.dltk.javascript.core.dom.Node;
import org.eclipse.dltk.javascript.core.dom.Source;
import org.eclipse.dltk.javascript.core.dom.rewrite.ASTConverter;
import org.eclipse.dltk.javascript.core.dom.rewrite.NodeFinder;
import org.eclipse.dltk.javascript.core.dom.rewrite.RefactoringUtils;
import org.eclipse.dltk.javascript.core.dom.rewrite.RewriteAnalyzer;
import org.eclipse.dltk.javascript.core.refactoring.descriptors.InlineMethodDescriptor;
import org.eclipse.dltk.javascript.parser.JavaScriptParserUtil;
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.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.TextChange;
import org.eclipse.ltk.core.refactoring.participants.ResourceChangeChecker;
import org.eclipse.ltk.internal.core.refactoring.BasicElementLabels;

/*
 * Open items:
 *  - generate import statements for newly generated local variable declarations.
 *  - forbid cases like foo(foo(10)) when inlining foo().
 *  - case ref.foo(); and we want to inline foo. Inline a method in a different context;
 *  - optimize code when the method to be inlined returns an argument and that one is
 *    assigned to a parameter again. No need for a separate local (important to be able
 *    to reverse extract method correctly).
 */
public class InlineMethodRefactoring extends Refactoring {

	private static final String ATTRIBUTE_MODE= "mode"; //$NON-NLS-1$
	private static final String ATTRIBUTE_DELETE= "delete";	 //$NON-NLS-1$

	public enum Mode {
		ALL,SINGLE;
	}
	
	// constructor
	private ISourceModule cu;
	private int offset;
	private int length;
	// initial conditions
	private IMethod method;
	private Mode initialMode;
	private Mode currentMode;
	private boolean deleteSource;
	private Source declRoot;
	private Node declNode; 
	private SourceProvider sourceProvider;
	private TargetProvider targetProvider;
	// final conditions
	private TextChangeManager changeManager;

	public InlineMethodRefactoring(ISourceModule cu, int offset, int length) {
		this.cu = cu;
		this.offset = offset;
		this.length = length;
		deleteSource= false;
	}

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

	/**
	 * Returns the method to inline, or null if the method could not be found or
	 * {@link #checkInitialConditions(IProgressMonitor)} has not been called yet.
	 *
	 * @return the method, or <code>null</code>
	 */
	public IMethod getMethod() {
		return method;
	}

	public boolean canEnableDeleteSource() {
		return !method.isReadOnly();
	}

	/*public boolean getDeleteSource() {
		return fDeleteSource;
	}*/

	public void setDeleteSource(boolean remove) {
		if (remove)
			Assert.isTrue(canEnableDeleteSource());
		deleteSource= remove;
	}

	public Mode getInitialMode() {
		return initialMode;
	}

	public RefactoringStatus setCurrentMode(Mode mode) {
		if (currentMode == mode)
			return new RefactoringStatus();
		Assert.isTrue(getInitialMode() == Mode.SINGLE);
		currentMode= mode;
		/*if (mode == Mode.INLINE_SINGLE) {
			if (fInitialNode instanceof MethodInvocation)
				fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (MethodInvocation)fInitialNode);
			else if (fInitialNode instanceof SuperMethodInvocation)
				fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (SuperMethodInvocation)fInitialNode);
			else if (fInitialNode instanceof ConstructorInvocation)
				fTargetProvider= TargetProvider.create((ICompilationUnit) fInitialTypeRoot, (ConstructorInvocation)fInitialNode);
			else
				throw new IllegalStateException(String.valueOf(fInitialNode));
		} else {
			fTargetProvider= TargetProvider.create(fSourceProvider.getDeclaration());
		}
		return fTargetProvider.checkActivation();*/
		return new RefactoringStatus();
	}

	/**
	 * Creates a new inline method refactoring
	 * @param unit the compilation unit or class file
	 * @param selectionStart start
	 * @param selectionLength length
	 * @return returns the refactoring
	 */
	/*public static InlineMethodRefactoring create(ISourceModule unit, int selectionStart, int selectionLength) {
		try {
			IModelElement[] elements = unit.codeSelect(selectionStart, selectionLength);
			if (elements.length != 1 || !(elements[0] instanceof IMethod))
				return null;
			IMethod method = (IMethod)elements[0];
			if (method.getSourceRange().getOffset() == selectionStart && method.getSourceModule() == unit) {
				return new InlineMethodRefactoring(unit, method, selectionStart, selectionLength, Mode.ALL);
			} else {
				return new InlineMethodRefactoring(unit, method, selectionStart, selectionLength, Mode.SINGLE);
			}
		} catch (ModelException e) {
			JavascriptManipulationPlugin.log(e);
		}
		return null;
	}*/

	public RefactoringStatus checkInitialConditions(IProgressMonitor pm) {
		RefactoringStatus result= new RefactoringStatus();
		if (method == null) {
			try {
				IModelElement[] elements = cu.codeSelect(offset, length);
				if (elements.length != 1 || !(elements[0] instanceof IMethod))
					return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.InlineMethodRefactoring_error_noMethodDeclaration);  
				method = (IMethod)elements[0];
				int start = method.getNameRange().getOffset(); 
				if (start <= offset && offset <= start+method.getNameRange().getLength() && method.getSourceModule() == cu)
					initialMode = Mode.ALL;
				else
					initialMode = Mode.SINGLE;
				currentMode = initialMode;
				declRoot = (Source)ASTConverter.convert(JavaScriptParserUtil.parse(method.getSourceModule()));
				declNode = NodeFinder.findNode(declRoot, method.getNameRange());
				FunctionExpression expr = RefactoringUtils.getFunctionDeclaration(declNode);
				if (expr == null)
					return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.InlineMethodRefactoring_error_noMethodDeclaration);
				sourceProvider = new SourceProvider(expr, method);
				if (result.hasFatalError())
					return result;
			} catch (ModelException e) {
				JavascriptManipulationPlugin.log(e);
				return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.InlineMethodRefactoring_error_noMethodDeclaration);  
			}
		}
		result.merge(sourceProvider.checkActivation());
		return result;
	}

	public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException {
		pm.beginTask("", 20); //$NON-NLS-1$
		changeManager= new TextChangeManager();
		RefactoringStatus result= new RefactoringStatus();
		sourceProvider.initialize();
		if (currentMode == Mode.ALL)
			targetProvider = TargetProvider.create(method);
		else {
			targetProvider = TargetProvider.create(cu, offset, length);
			deleteSource = false;
		}
		//fTargetProvider.initialize();

		pm.setTaskName(RefactoringCoreMessages.InlineMethodRefactoring_searching);
		RefactoringStatus searchStatus= new RefactoringStatus();
		/*String binaryRefsDescription= Messages.format(RefactoringCoreMessages.ReferencesInBinaryContext_ref_in_binaries_description , BasicElementLabels.getJavaElementName(fSourceProvider.getMethodName()));
		ReferencesInBinaryContext binaryRefs= new ReferencesInBinaryContext(binaryRefsDescription);*/
		List<ISourceModule> units= targetProvider.getAffectedSourceModules(searchStatus, new SubProgressMonitor(pm, 1));
		//binaryRefs.addErrorIfNecessary(searchStatus);
		if (searchStatus.hasFatalError()) {
			result.merge(searchStatus);
			return result;
		}

		IFile[] filesToBeModified= getFilesToBeModified(units);
		result.merge(RefactoringChecks.validateModifiesFiles(filesToBeModified, getValidationContext()));
		if (result.hasFatalError())
			return result;
		result.merge(ResourceChangeChecker.checkFilesToBeChanged(filesToBeModified, new SubProgressMonitor(pm, 1)));
		// TODO check overrides
		//checkOverridden(result, new SubProgressMonitor(pm, 4));
		IProgressMonitor sub= new SubProgressMonitor(pm, 15);
		sub.beginTask("", (units.size()+1) * 3); //$NON-NLS-1$
		boolean occursInDeclUnit = false;
		for(ISourceModule unit : units) {
			if (!unit.equals(method.getSourceModule()))
				processUnit(unit,sub,result);
			else
				occursInDeclUnit = true;
		}
		if (occursInDeclUnit)
			sub.worked(3);
		if (deleteSource || occursInDeclUnit)
			processUnit(method.getSourceModule(),sub,result);
		result.merge(searchStatus);
		sub.done();
		pm.done();
		return result;
	}
	
	private void processUnit(ISourceModule unit, IProgressMonitor pm, RefactoringStatus result) throws CoreException {
		pm.subTask(Messages.format(RefactoringCoreMessages.InlineMethodRefactoring_processing,  BasicElementLabels.getResourceName(unit.getCorrespondingResource())));
		CallInliner inliner= null;
			boolean modified = false;
			Source root = targetProvider.getRoot(unit);
			ChangeRecorder cr = new ChangeRecorder(targetProvider.getRoot(unit));
			Node[] bodies=targetProvider.getAffectedBodyDeclarations(unit, new SubProgressMonitor(pm, 1));
			if (bodies.length == 0)
				return;
			inliner = new CallInliner(unit, sourceProvider);
			for(Node body : bodies) {
				inliner.initialize(body);
				RefactoringStatus nestedInvocations= new RefactoringStatus();
				CallExpression[] invocations= removeNestedCalls(nestedInvocations, unit,
					targetProvider.getInvocations(body, new SubProgressMonitor(pm, 2)));
				for(CallExpression invocation : invocations) {
					RefactoringStatus checkInline = inliner.initialize(invocation, targetProvider.getStatusSeverity());
					result.merge(checkInline);
					if (result.hasFatalError())
						break;
					if (checkInline.getSeverity() >= targetProvider.getStatusSeverity()) {
						deleteSource= false;
					} else {
						modified = true;
						inliner.perform();
					}
				}
				// do this after we have inlined the method calls. We still want
				// to generate the modifications.
				if (!nestedInvocations.isOK()) {
					result.merge(nestedInvocations);
					deleteSource=false;
				}
			}
			if (deleteSource && unit.equals(method.getSourceModule())) {
				modified = true;
				Node node = sourceProvider.getDeclaration();
				node = NodeFinder.findNode(root, node.getBegin(), node.getEnd());
				while (!node.eContainmentFeature().isMany())
					node = (Node)node.eContainer();
				List<? extends Node> list = (List<? extends Node>)node.eContainer().eGet(node.eContainmentFeature());
				list.remove(node);
			}
			if (modified) {
				ChangeDescription cd = cr.endRecording();
				RewriteAnalyzer rewrite = new RewriteAnalyzer(cd, unit.getSource());
				rewrite.rewrite(root);
				cd.apply();
				TextChange change = new SourceModuleChange(unit.getElementName(), unit);
				change.setEdit(rewrite.getEdit());
				changeManager.manage(unit, change);
			} else
				cr.endRecording();
			/*if (!added) {
				changeManager.remove(unit);
			} else {
				root.addChild(inliner.getModifications());
				ImportRewrite rewrite= inliner.getImportEdit();
				if (rewrite.hasRecordedChanges()) {
					TextEdit edit= rewrite.rewriteImports(null);
					if (edit instanceof MultiTextEdit ? ((MultiTextEdit)edit).getChildrenSize() > 0 : true) {
						root.addChild(edit);
						change.addTextEditGroup(
							new TextEditGroup(RefactoringCoreMessages.InlineMethodRefactoring_edit_import, new TextEdit[] {edit}));
					}
				}
			}*/
		pm.worked(1);
		if (pm.isCanceled())
			throw new OperationCanceledException();
	}

	public Change createChange(IProgressMonitor pm) throws CoreException {
		//if (deleteSource && currentMode == Mode.ALL) {
			//TextChange change= changeManager.get((ISourceModule) sourceProvider.getTypeRoot());
			//TextEdit delete= sourceProvider.getDeleteEdit();
			//TextEditGroup description= new TextEditGroup(
			//	RefactoringCoreMessages.InlineMethodRefactoring_edit_delete, new TextEdit[] { delete });
			//TextEdit root= change.getEdit();
			//if (root != null) {
				// TODO instead of finding the right insert position the call inliner should
				// reuse the AST & rewriter of the source provide and we should rewrite the
				// whole AST at the end. However, since recursive calls aren't allowed there
				// shouldn't be a text edit overlap.
				// root.addChild(delete);
				//TextChangeCompatibility.insert(root, delete);
			//} else {
				//change.setEdit(delete);
			//}
			//change.addTextEditGroup(description);
		//}
		final Map arguments= new HashMap();
		String project = null;
		IScriptProject scriptProject= cu.getScriptProject();
		if (scriptProject != null)
			project= scriptProject.getElementName();
		int flags= RefactoringDescriptor.STRUCTURAL_CHANGE | ScriptRefactoringDescriptor.ARCHIVE_REFACTORABLE | ScriptRefactoringDescriptor.ARCHIVE_IMPORTABLE;
		//final IMethodBinding binding= sourceProvider.getDeclaration().resolveBinding();
		//final ITypeBinding declaring= binding.getDeclaringClass();
		//if (!Modifier.isPrivate(binding.getModifiers()))
		//	flags|= RefactoringDescriptor.MULTI_CHANGE;
		final String description= Messages.format(RefactoringCoreMessages.InlineMethodRefactoring_descriptor_description_short, method.getElementName());
		final String header= Messages.format(RefactoringCoreMessages.InlineMethodRefactoring_descriptor_description, new String[] { method.getElementName(), cu.getElementName() });
		//final JDTRefactoringDescriptorComment comment= new JDTRefactoringDescriptorComment(project, this, header);
		//comment.addSetting(Messages.format(RefactoringCoreMessages.InlineMethodRefactoring_original_pattern, BindingLabelProvider.getBindingLabel(binding, JavaElementLabels.ALL_FULLY_QUALIFIED)));
		//if (fDeleteSource)
		//	comment.addSetting(RefactoringCoreMessages.InlineMethodRefactoring_remove_method);
		//if (fCurrentMode == Mode.INLINE_ALL)
		//	comment.addSetting(RefactoringCoreMessages.InlineMethodRefactoring_replace_references);
		final InlineMethodDescriptor descriptor = new InlineMethodDescriptor(project, description, ""/*comment.asString()*/, arguments, flags);
		arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_INPUT, ScriptRefactoringDescriptor.elementToHandle(project, cu));
		arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_SELECTION, new Integer(offset).toString() + " " + new Integer(length).toString()); //$NON-NLS-1$
		arguments.put(ATTRIBUTE_DELETE, Boolean.valueOf(deleteSource).toString());
		arguments.put(ATTRIBUTE_MODE, new Integer(currentMode == Mode.ALL ? 1 : 0).toString());
		return new DynamicValidationRefactoringChange(descriptor, RefactoringCoreMessages.InlineMethodRefactoring_edit_inlineCall, changeManager.getAllChanges());
	}
	
	//private static SourceProvider resolveSourceProvider(RefactoringStatus status, Node nameNode) {
		/*IMethodBinding methodBinding= Invocations.resolveBinding(invocation);
		if (methodBinding == null) {
			status.addFatalError(RefactoringCoreMessages.InlineMethodRefactoring_error_noMethodDeclaration);
			return null;
		}*/
		/*MethodDeclaration declaration= (MethodDeclaration)root.findDeclaringNode(methodBinding);
		if (declaration != null) {
			return new SourceProvider(typeRoot, declaration);
		}
		IMethod method= (IMethod)methodBinding.getJavaElement();
		if (method != null) {
			CompilationUnit methodDeclarationAstRoot;
			ICompilationUnit methodCu= method.getCompilationUnit();
			if (methodCu != null) {
				methodDeclarationAstRoot= new RefactoringASTParser(AST.JLS3).parse(methodCu, true);
			} else {
				IClassFile classFile= method.getClassFile();
				if (! JavaElementUtil.isSourceAvailable(classFile)) {
					String methodLabel= JavaElementLabels.getTextLabel(method, JavaElementLabels.M_FULLY_QUALIFIED | JavaElementLabels.M_PARAMETER_TYPES);
					status.addFatalError(Messages.format(RefactoringCoreMessages.InlineMethodRefactoring_error_classFile, methodLabel));
					return null;
				}
				methodDeclarationAstRoot= new RefactoringASTParser(AST.JLS3).parse(classFile, true);
			}
			ASTNode node= methodDeclarationAstRoot.findDeclaringNode(methodBinding.getMethodDeclaration().getKey());
			if (node instanceof MethodDeclaration) {
				return new SourceProvider(methodDeclarationAstRoot.getTypeRoot(), (MethodDeclaration) node);
			}
		}*/
	//}

	private IFile[] getFilesToBeModified(List<ISourceModule> units) {
		List<IFile> result= new ArrayList<IFile>(units.size() + 1);
		for (ISourceModule unit : units) {
			IFile file= getFile(unit);
			if (file != null)
				result.add(file);
		}
		if (deleteSource) {
			IFile file = getFile(method.getSourceModule());
			if (file != null && !units.contains(file))
				result.add(file);
		}
		return (IFile[])result.toArray(new IFile[result.size()]);
	}

	private IFile getFile(ISourceModule unit) {
		unit= unit.getPrimary();
		IResource resource= unit.getResource();
		if (resource != null && resource.getType() == IResource.FILE)
			return (IFile)resource;
		return null;
	}

	/*private void checkOverridden(RefactoringStatus status, IProgressMonitor pm) throws JavaModelException {
		pm.beginTask("", 9); //$NON-NLS-1$
		pm.setTaskName(RefactoringCoreMessages.InlineMethodRefactoring_checking_overridden);
		MethodDeclaration decl= fSourceProvider.getDeclaration();
		IMethod method= (IMethod) decl.resolveBinding().getJavaElement();
		if (method == null || Flags.isPrivate(method.getFlags())) {
			pm.worked(8);
			return;
		}
		IType type= method.getDeclaringType();
		ITypeHierarchy hierarchy= type.newTypeHierarchy(new SubProgressMonitor(pm, 6));
		checkSubTypes(status, method, hierarchy.getAllSubtypes(type), new SubProgressMonitor(pm, 1));
		checkSuperClasses(status, method, hierarchy.getAllSuperclasses(type), new SubProgressMonitor(pm, 1));
		checkSuperInterfaces(status, method, hierarchy.getAllSuperInterfaces(type), new SubProgressMonitor(pm, 1));
		pm.setTaskName(""); //$NON-NLS-1$
	}

	private void checkSubTypes(RefactoringStatus result, IMethod method, IType[] types, IProgressMonitor pm) {
		checkTypes(
			result, method, types,
			RefactoringCoreMessages.InlineMethodRefactoring_checking_overridden_error,
			pm);
	}

	private void checkSuperClasses(RefactoringStatus result, IMethod method, IType[] types, IProgressMonitor pm) {
		checkTypes(
			result, method, types,
			RefactoringCoreMessages.InlineMethodRefactoring_checking_overrides_error,
			pm);
	}

	private void checkSuperInterfaces(RefactoringStatus result, IMethod method, IType[] types, IProgressMonitor pm) {
		checkTypes(
			result, method, types,
			RefactoringCoreMessages.InlineMethodRefactoring_checking_implements_error,
			pm);
	}
	private void checkTypes(RefactoringStatus result, IMethod method, IType[] types, String key, IProgressMonitor pm) {
		pm.beginTask("", types.length); //$NON-NLS-1$
		for (int i= 0; i < types.length; i++) {
			pm.worked(1);
			IMethod[] overridden= types[i].findMethods(method);
			if (overridden != null && overridden.length > 0) {
				result.addError(
					Messages.format(key, JavaElementLabels.getElementLabel(types[i], JavaElementLabels.ALL_DEFAULT)),
					JavaStatusContext.create(overridden[0]));
			}
		}
	}*/

	private CallExpression[] removeNestedCalls(RefactoringStatus status, ISourceModule unit, CallExpression[] invocations) {
		List<Node> result= new ArrayList<Node>();
		for(Node invocation : invocations) {
			boolean ok = true;
			for (Node parent : invocations) {
				parent = (Node)parent.eContainer();
				while (parent != null && parent != invocation)
					parent=(Node)parent.eContainer();
				if (parent != null)
					ok = false;
			}
			if (ok)
				result.add(invocation);
			else
				status.addError(RefactoringCoreMessages.InlineMethodRefactoring_nestedInvocation/*,
					JavaStatusContext.create(unit, parent)*/);
		}
		return result.toArray(new CallExpression[result.size()]);
	}
}