/*******************************************************************************
 * Copyright (c) 2010 SpringSource 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:
 *     Kris De Volder - initial API and implementation
 *******************************************************************************/
package org.eclipse.ajdt.internal.ui.refactoring.pullout;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.ajdt.core.javaelements.AJCompilationUnit;
import org.eclipse.ajdt.core.javaelements.AspectElement;
import org.eclipse.ajdt.core.javaelements.IntertypeElement;
import org.eclipse.ajdt.core.javaelements.SourceRange;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeParameter;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.ConstructorInvocation;
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.MethodDeclaration;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
import org.eclipse.jdt.core.manipulation.ImportReferencesCollector;
import org.eclipse.jdt.core.refactoring.CompilationUnitChange;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchMatch;
import org.eclipse.jdt.core.search.SearchParticipant;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.core.search.SearchRequestor;
import org.eclipse.jdt.internal.corext.refactoring.base.JavaStatusContext;
import org.eclipse.jdt.internal.corext.util.CodeFormatterUtil;
import org.eclipse.jdt.internal.corext.util.JdtFlags;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Region;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.RefactoringStatusContext;
import org.eclipse.text.edits.DeleteEdit;
import org.eclipse.text.edits.InsertEdit;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.text.edits.TextEdit;

public class PullOutRefactoring extends Refactoring {
    
    /**
     * An instance of this class pulls together all required info for
     * the rewriting of the aspect and handles the rewriting.
     */
    class AspectRewrite {
        
        /**
         * Collects the text of all ITDs.
         */
        private StringBuffer itds = new StringBuffer();
        
        /**
         * Collects info for and handles rewriting of imports for the target aspect.
         */
        private ImportRewrite importRewrite;

        /**
         * This field may be set while creating the "deletion" edits to pull out ITDs.
         * This will only happen if the compilation unit from which we are pulling out 
         * is the same as the target aspect's compilation unit. If set to a non-null
         * value this cuChange object should be used for recording the "insertion"
         * edits.
         */
        private CompilationUnitChange cuChange = null;
        
        public AspectRewrite() throws JavaModelException {
            importRewrite = ImportRewrite.create(targetAspect.getCompilationUnit(), true);
        }

        public void addITD(ITDCreator itd, RefactoringStatus status) throws JavaModelException, BadLocationException {
            itd.collectImports(importRewrite, status);
            itds.append(itd.createText());
        }


        /**
         * Create an ICompiltationUnitChange with all changes to the aspect's CU, related to the insertion 
         * of ITDs. Ensure these changes are added to the allChanges object.
         */
        private void rewriteAspect(IProgressMonitor submonitor, CompositeChange allChanges) {
            try {
                CompilationUnitChange edits = getCUChange();
                
                // Create edit to add "privileged"
                if (isMakePrivileged() && !isPrivileged()) {
                    int start = targetAspect.getSourceRange().getOffset();
                    int nameStart = targetAspect.getNameRange().getOffset() - start;
                    String aspectText = targetAspect.getSource().substring(0,nameStart);
                    // If all is well, we now have the aspectText, upto the keywords "aspect"
                    // Caveat: for some reason AJDT has replaced this keyword by the "class" keyword.
                    int aspectKeywordStart = aspectText.lastIndexOf("class");
                    Assert.isTrue(aspectKeywordStart>=0, "The aspect keyword was not found in the aspect source");
                    aspectKeywordStart += start; // Adjust because the start of our string may not be the
                                                 // start of the compilation unit.
                    edits.addEdit(new InsertEdit(aspectKeywordStart, "privileged "));
                }
                
                // Create edit to the imports section of compilation unit
                if (importRewrite.hasRecordedChanges()) {
                    try {
                        edits.addEdit(importRewrite.rewriteImports(submonitor));
                    } catch (Exception e) {
                        //An aspect handles this
                    }
                }
                
                // Add the itds to the aspect
                edits.addEdit(new InsertEdit(getInsertLocation(), itds.toString()));

                if (edits.getParent()==null) {
                    allChanges.add(edits);
                }
                else {
                    //If not null, it means we already added it, because the aspect is
                    //in the same CU as some pulled out members.
                }
            } catch (JavaModelException e) {
            }
        }
        
        /**
         * Get the CompilationUnitChange object that should be used to record the changes related to
         * inserting ITDs into the aspect. The object is created if necessary, or reused if it
         * already exists.
         */
        private CompilationUnitChange getCUChange() {
            if (cuChange==null) {
                cuChange = newCompilationUnitChange(getAspect().getCompilationUnit());
                cuChange.setEdit(new MultiTextEdit()); // root element must be set, or we can't add edits!
            }
            return cuChange;
        }

        public void setCUChange(CompilationUnitChange cuChange) {
            this.cuChange = cuChange;
        }

    }

    /**
     * Helper class to create ITD text from a member. An instance of this class is created
     * to provide a working area in which to build the ITD text.
     * <p>
     * This class was introduced to help manage the complexity of context information that 
     * was getting passed along with various helper methods that break down the creation of an ITD
     * into smaller steps. This was starting to result in extremely long argument lists.
     * <p>
     * This class keeps all that information in one convenient place. It also provides a nice
     * high-level interface to manipulate the properties of the created ITD, while encapsulating
     * the messier parts of the rewriting and text manipulation code inside the class. 
     * 
     * @author kdvolder
     */
    static class ITDCreator {
        
        private static final int VISIBILITY_MODIFIERS = Modifier.PRIVATE | Modifier.PUBLIC | Modifier.PROTECTED;

        /**
         * The original member from which we create the ITD
         */
        private IMember member;
        
        /**
         * The AST node corresponding to the original member.
         */
        private BodyDeclaration memberNode;

        /**
         * We place the text of the original member in this document, so that
         * we can accumulate and apply edits against the document to create
         * the final ITD text.
         */
        private IDocument memberText;
        
        /**
         * Rather than applying edits immeditiately, we accumulate them in here, this is so that
         * we don't end up destroying position information before we have figured out
         * all the edits to apply to the original text.
         */
        private MultiTextEdit edits = new MultiTextEdit();
        
        /**
         * Modifiers that should be removed when we rewrite the ITD's modifiers.
         * This is a "bitfield". See {@link Modifier} for the meaning of the bits.
         */
        private int deleteMods = 0;
        
        /**
         * Either an empty String, or a String containing all the modifiers to add, separated 
         * by spaces and with one trailing space.
         */
        private String insertMods = "";

        /**
         * The name of the declaring type, as it should be written in the aspect context (i.e. as
         * a simple name, or a fully qualified name, depending on whether it could be imported.
         * <p>
         * This field is initialized during "collectImports".
         */
        private String declaringTypeRef = null;
        
        /**
         * The ITD creator requires an IMember and its corresponding AST node, to be
         * able to perform its work of creating the ITD text.
         * 
         * @param member
         * @param memberNode
         * @throws JavaModelException 
         */
        public ITDCreator(IMember member, BodyDeclaration memberNode) throws JavaModelException {
            this.member = member;
            this.memberNode = memberNode;
            this.memberText = new Document(getAJSource(member));
        }
        
        /**
         * Aspect aware method for getting source code. For elements inside an .aj file, it fetches the 
         * "original" source code, not the rewritten source code. For elements in regular .java file
         * it is identical to the getSource method.
         */
        private String getAJSource(IMember member) throws JavaModelException {
            ICompilationUnit cu = member.getCompilationUnit();
            if (cu instanceof AJCompilationUnit) {
                AJCompilationUnit ajcu = (AJCompilationUnit) cu;
                ajcu.requestOriginalContentMode();
                try {
                    return member.getSource();
                }
                finally {
                    ajcu.discardOriginalContentMode();
                }
            }
            return member.getSource();
        }

        @Override
        public String toString() {
            if (memberText==null)
                return "ITDCreator(DISPOSED)";
            else {
                return "ITDCreator(----\n" +
                memberText.get()+"\n" +
                "----)";
            }
        }
        
        /**
         * Collect imports needed for this ITD, and add them to the aspects compilation unit's 
         * importRewriter.
         * <p>
         * This also applies the necessary edits to the ITD text if some imports fail because
         * of name clashes.
         * <p>
         * If some references can't be resolved a warning is added to the refactoring satus.
         */
        public void collectImports(ImportRewrite importRewrite, RefactoringStatus status) throws JavaModelException {
            Region rangeLimit = new Region(memberNode.getStartPosition(), memberNode.getLength());
            
			List<SimpleName> extraType = new ArrayList<SimpleName>();
			List<SimpleName> extraStatic = new ArrayList<SimpleName>();
            
            ImportReferencesCollector.collect(memberNode, member.getJavaProject(), rangeLimit, extraType, extraStatic);
            
            for (Name name : extraStatic) {
                IBinding binding = name.resolveBinding();
                if (binding==null) {
                    status.addWarning("Couldn't resolve binding, imports may be incorrect", PullOutRefactoring.makeContext(member, name));
                }
                else {
                    replaceNameRef(name, importRewrite.addStaticImport(binding));
                }
            }
                
            for (Name name : extraType) {
                ITypeBinding binding = (ITypeBinding)name.resolveBinding();
                if (binding==null) {
                    status.addWarning("Couldn't resolve binding, imports may be incorrect", PullOutRefactoring.makeContext(member, name));
                }
                else {
                    if (binding.isParameterizedType()) {
                        // Simple names should not be treated as complete generic type references
                        binding = binding.getErasure(); 
                    }
                    replaceNameRef(name, importRewrite.addImport(binding));
                }
            }
            
            if (wasIntertype()) {
                IntertypeElement ite = (IntertypeElement) member;
                AJCompilationUnit cu = (AJCompilationUnit) ite.getCompilationUnit();
                IType targetType = ite.findTargetType();
                String typeQName = targetType!=null?targetType.getFullyQualifiedName():ite.getTargetName();
                declaringTypeRef = importRewrite.addImport(typeQName);
            }
            else {
                declaringTypeRef = importRewrite.addImport(member.getDeclaringType().getFullyQualifiedName());
            }
        }

        /**
         * @return true if the original pulled out member was *already* an ITD.
         */
        private boolean wasIntertype() {
            return member instanceof IntertypeElement;
        }

        /**
         * Add an extra textedit, if needed for updating a potentially failed import rewrite
         */
        private void replaceNameRef(Name name, String replaceStr) throws MalformedTreeException, JavaModelException {
            String orgRefText = name.getFullyQualifiedName();
            if (replaceStr.equals(orgRefText))
                return;
            edits.addChild(new ReplaceEdit(
                    name.getStartPosition()-memberStart(), 
                    name.getLength(), 
                    replaceStr));
        }

        
        /**
         * Create the necessary edits to change modifiers on the ITD as described by the
         * deleteMods and insertMods fields.
         */
        private void rewriteModifiers()
        throws BadLocationException, MalformedTreeException, JavaModelException 
        {
            if (deleteMods!=0) {
                List<Modifier> mods = memberNode.modifiers();
                //String replaceText = makePublic?"public ":"";
                String replaceText = "";
                for (Modifier modifier : mods) {
                    if ( (modifier.getKeyword().toFlagValue() & deleteMods) != 0) {
                        int modStart = modifier.getStartPosition() - memberStart();
                        int modEnd = modStart + modifier.getLength();
                        if (Character.isWhitespace(memberText.getChar(modEnd))) {
                            // Delete one extra white space character for a nicer look.
                            // but only if there is one! (imagine there being a weird comment there instead)
                            modEnd++;
                        }
                        edits.addChild(new ReplaceEdit(modStart, modEnd-modStart, replaceText));
                    }
                }
            }
            if (insertMods!=null && !"".equals(insertMods)) {
                int insertPos;
                if (memberNode instanceof MethodDeclaration) {
                    MethodDeclaration methodNode = (MethodDeclaration) memberNode;
                    if (methodNode.isConstructor())
                        insertPos = methodNode.getName().getStartPosition() - memberStart();
                    else
                        insertPos = methodNode.getReturnType2().getStartPosition() - memberStart();
                }
                else if (memberNode instanceof FieldDeclaration ) {
                    FieldDeclaration fieldNode = (FieldDeclaration) memberNode;
                    insertPos = fieldNode.getType().getStartPosition() - memberStart();
                }
                else {
                    insertPos = 0;
                }
                edits.addChild(new InsertEdit(insertPos, insertMods));
            }
        }
        
        private int memberStart() throws JavaModelException {
            return member.getSourceRange().getOffset();
        }

        public void removeModifier(int mod) {
            this.deleteMods |= mod;
        }

        /**
         * Produce text for the ITD, by applying all requested changes to the
         * original ITD text.
         * <p>
         * This is a 'once only' operation. After the text of the ITD is created
         * this object has served its purpose and should not be used anymore.
         * @throws JavaModelException 
         * @throws BadLocationException 
         * @throws MalformedTreeException 
         */
        public String createText() throws JavaModelException, MalformedTreeException, BadLocationException {
            try {
                int memberStart = memberStart();

                // All positions, except for memberStart itself, will be computed relative to member
                // start (since our memberText document only contains the member text)

                int memberEnd = memberText.getLength();
                int nameStart = member.getNameRange().getOffset() - memberStart;

                // Add some indentation correction to the front
                edits.addChild(
                        new InsertEdit(0, CodeFormatterUtil.createIndentString(1, member.getJavaProject())));

                // Rewrite modifiers
                rewriteModifiers();

                //Rewrite stuff in and around the name... only when original is *not* an intertype element!
                if (!wasIntertype()) {
                    // Insert declaring type reference in front of name
                    IType declaringType = member.getDeclaringType();
                    Assert.isNotNull(declaringTypeRef, "The declaring type name is computed by collectImports. Forgot to call it?");
                    StringBuffer typeName = new StringBuffer(declaringTypeRef);
                    ITypeParameter[] typeParameters = declaringType.getTypeParameters();
                    if (typeParameters !=null && typeParameters.length>0) {
                        typeName.append("<");
                        for (int i = 0; i < typeParameters.length; i++) {
                            if (i>0) typeName.append(", ");
                            typeName.append(typeParameters[i].getElementName());
                        }
                        typeName.append(">");
                    }
                    typeName.append( "." );
                    edits.addChild(new InsertEdit(nameStart, typeName.toString()));
                    
                    // For constructors, must change name to "new"
                    if (member instanceof IMethod && ((IMethod)member).isConstructor()) {
                        edits.addChild(new ReplaceEdit(nameStart, member.getNameRange().getLength(), "new"));
                    }
                }

                // Add some newlines to the end for nicer spacing
                String newline = memberText.getLineDelimiter(0);
                if (newline==null) // We tried to use the same as in the memberText but it has none
                    newline = System.getProperty("line.separator"); 
                edits.addChild(new InsertEdit(memberEnd,  newline+newline));

                // applying these edits should produce the ITD text
                edits.apply(memberText, TextEdit.NONE);
                return memberText.get();
            }
            finally {
                // This object has served it's purpose and should not be reused.
                dispose();
            }
        }

        /**
         * Destroy this object. Further use of the object will probably cause NPE exception.
         */
        private void dispose() {
            member = null;
            memberNode = null;
            memberText = null;
            edits = null;
            insertMods = null;
            declaringTypeRef = null;
        }

        /**
         * Was the original member protected. 
         */
        public boolean wasProtected() throws JavaModelException {
            return JdtFlags.isProtected(member);
        }

        /**
         * Was the original member public. 
         */
        public boolean wasPublic() throws JavaModelException {
            return JdtFlags.isPublic(member);
        }

        /**
         * Was the original member private. 
         */
        public boolean wasPrivate() throws JavaModelException {
            return JdtFlags.isPrivate(member);
        }
        
        /**
         * Was the original member abstract.
         */
        public boolean wasAbstract() throws JavaModelException {
            return JdtFlags.isAbstract(member);
        }
        
        /**
         * Was the original member "package visible" (i.e. it has no visibility
         * modifiers at all. 
         */
        public boolean wasPackageVisible() throws JavaModelException {
            return JdtFlags.isPackageVisible(member);
        }

        /**
         * Get the original member from which we are creating an ITD. 
         */
        public IMember getMember() {
            return member;
        }

        /**
         * Get the IJavaElement name of the original member. 
         */
        public String getElementName() {
            return member.getElementName();
        }

        public ASTNode getMemberNode() {
            return memberNode;
        }

        public void addModifier(int modFlag) {
            if (isVisibilityModifier(modFlag)) {
                //When adding a visiblity modifier, make sure to remove any preexisting
                //visibility modifiers first
                deleteMods |= VISIBILITY_MODIFIERS;
            }
            ModifierKeyword toAdd = ModifierKeyword.fromFlagValue(modFlag);
            String toAddStr = toAdd.toString();
            removeModifier(modFlag);
            if (!insertMods.contains(toAddStr)) {
                insertMods += toAddStr+" ";
            }
        }

        private boolean isVisibilityModifier(int modFlag) {
            return (modFlag & VISIBILITY_MODIFIERS)!=0;
        }

        /**
         * Replace the body of the method with given text. This is really only
         * supposed to be used to add method stubs for methods that where abstract
         * before.
         */
        public void setBody(String bodyText) {
            Object bodyNode = memberNode.getStructuralProperty(MethodDeclaration.BODY_PROPERTY);
            Assert.isTrue(bodyNode==null, "There already is a method body for this member: "+getMember());
            int startPos = memberText.get().lastIndexOf(';');
            edits.addChild(new ReplaceEdit(startPos, 1, bodyText));
        }

        /**
         * Is the original member a constructor (does not include the case where the original member is
         * already an ITD, even if that ITD introduces a constructor).
         */
        public boolean wasConstructorMethod() throws JavaModelException {
            return (member instanceof IMethod) && !wasIntertype() && ((IMethod)member).isConstructor();
        }

        /**
         * Determine whether this ITD's original member (which is assumed to be a constructor) has a
         * call to 'this()'
         */
        public boolean hasThisCall() throws JavaModelException {
            Assert.isNotNull(memberNode);
            Assert.isLegal(wasConstructorMethod());
            Block body = ((MethodDeclaration)memberNode).getBody();
            if (body==null) return false;
            @SuppressWarnings("unchecked") List<Statement> stms = body.statements();
            if (stms==null || stms.size()==0) return false;
            Statement firstStm = stms.get(0); 
            if (!(firstStm instanceof ConstructorInvocation)) return false;
            ConstructorInvocation call = (ConstructorInvocation) firstStm;
            // The class ConstructorInvocation only represents "this(...)" calls 
            return call.arguments().isEmpty();
        }
    }
    
    private static final String MAKE_PRIVILEGED = "makePrivileged";
    private static final String MEMBER = "member";

    protected static final String ASPECT = "aspect";
    
    /**
     * The members to pull out, grouped by compilation unit for efficiency sake (
     * so we can process them one CU at a time)
     */
    private Map<ICompilationUnit, Collection<IMember>> memberMap;
    private HashSet<IMember> memberSet;
    
    /**
     * The target aspect to where the method should be moved.
     */
    private AspectElement targetAspect;
        
    /**
     * Should we make the aspect privileged
     */
    private boolean makePrivileged = false;
    
    /**
     * Allow pulling abstract methods. This deletes abstract keyword and generates
     * method stubs for "abstract" ITDs.
     */
    private boolean generateAbstractMethodStubs = false;

    /**
     * Allow the deletion of the protected keyword from ITDs (because this keyword
     * is not allowed on ITDs by AspectJ).
     */
    private boolean allowDeleteProtected = false;

    /**
     * Allow to make ITDs public to avoid breaking references to pulled members.
     */
    private boolean allowMakePublic;
    
    private IJavaProject javaProject;
    private AspectRewrite aspectChanges;
    
    public PullOutRefactoring() {
        clearMembers(); // initializes the member map and sets
    }

    public void addMember(IMember member, RefactoringStatus status) {
        ICompilationUnit cu = member.getCompilationUnit();
        Collection<IMember> members = getMembers(cu);
        members.add(member);
        memberSet.add(member);
        if (javaProject==null) 
            javaProject = member.getJavaProject();
        else if (javaProject!=member.getJavaProject()) 
            status.addError("Pull-out refactoring across multiple projects is not suppored", makeContext(member));
    }
    
    @Override
    public RefactoringStatus checkFinalConditions(IProgressMonitor pm)
            throws CoreException, OperationCanceledException {
        RefactoringStatus status = new RefactoringStatus();
        SubProgressMonitor submonitor = new SubProgressMonitor(pm, memberMap.keySet().size());
        submonitor.beginTask("Checking preconditions...", memberMap.keySet().size());
        try {
            aspectChanges = new AspectRewrite();
            // For a more predictable and orderly outcome, sort by the name of the CU
            ICompilationUnit[] cus = memberMap.keySet().toArray(new ICompilationUnit[0]);
            Arrays.sort(cus, CompilationUnitComparator.the);
            for (ICompilationUnit cu : cus) {
                ASTParser parser= ASTParser.newParser(AST.JLS8);
                parser.setSource(cu);
                parser.setResolveBindings(true);
                ASTNode cuNode = parser.createAST(pm);
                for (IMember member : memberMap.get(cu)) {
                    BodyDeclaration memberNode = (BodyDeclaration) findASTNode(cuNode, member);
                    ITDCreator itd = new ITDCreator(member, memberNode);
                    if (member.getDeclaringType().isInterface()) {
                        // No need to check "isAllowMakePublic" since technically it was already public.
                        itd.addModifier(Modifier.PUBLIC);
                    }
                    if (itd.wasProtected()) {
                        if (isAllowDeleteProtected()) {
                            itd.removeModifier(Modifier.PROTECTED);
                        }
                        else {
                            status.addWarning("moved member '"+member.getElementName()+"' is protected\n" +
                                    "protected ITDs are not allowed by AspectJ.\n" ,
                                    makeContext(member));
                        }
                    }
                    if (itd.wasAbstract()) {
                        if (isGenerateAbstractMethodStubs()) {
                            itd.removeModifier(Modifier.ABSTRACT);
                            itd.setBody(getAbstractMethodStubBody(member));
                        }
                        else {
                            status.addWarning("moved member '"+member.getElementName()+"' is abstract.\n" +
                                    "abstract ITDs are not allowed by AspectJ.\n" +
                                    "You can enable the 'convert abstract methods' option to avoid this error.", 
                                    makeContext(member));
                            //If you choose to ignore this error and perform refactoring anyway...
                            // We make sure the abstract keyword is added to the itd, so you will get a compile error
                            // and be forced to deal with that error.
                            itd.addModifier(Modifier.ABSTRACT);
                        }
                    }
                    checkOutgoingReferences(itd, status);
                    checkIncomingReferences(itd, status);
                    checkConctructorThisCall(itd, status);
                    aspectChanges.addITD(itd, status);
                }
                submonitor.worked(1);
            }
        } catch (BadLocationException e) {
            status.merge(RefactoringStatus.createFatalErrorStatus("Internal error:"+e.getMessage()));
        }
        finally {
            submonitor.done();
        }
        return status;
    }

    /**
     * Check whether the constructor is "safe" to pull out, or whether it might change
     * the meaning of the program (no longer executing initialiser code in target class).
     * See https://bugs.eclipse.org/bugs/show_bug.cgi?id=318936
     */
    private void checkConctructorThisCall(ITDCreator itd,
            RefactoringStatus status) throws JavaModelException {
        if (itd.wasConstructorMethod() && !itd.hasThisCall()) {
            status.addWarning("Program semantics changed: moved '"+itd.getElementName()+"' constructor has no this() call. Initializers in the target class will not be executed " +
                    "by the intertype constructor", makeContext(itd.getMember()));
        }
    }

    /**
     * Find AST node corresponding to a given IMember.
     */
    private ASTNode findASTNode(ASTNode cuNode, IMember member)
            throws JavaModelException {
        ISourceRange range = member.getSourceRange();
        NodeFinder finder = new NodeFinder(cuNode, range.getOffset(), range.getLength());
        return finder.getCoveredNode(); 
        // Note: why we *have* to use getCoveredNode explicitly rather than use the
        // perform methods defined on NodeFinder.
        // See BUG 316945: Normally, we have exact positions and covering/covered are the same node.
        // but in the BUG case we should use the covered node since a JDT bug makes the source range 
        // be too large.
    }

    /**
     * Check whether references to moved elements become broken. Update status message
     * accordingly (but only if allowModifierConversion is set to false).
     * 
     * @return true if no references become broken
     */
    private boolean checkIncomingReferences(ITDCreator movedMember, RefactoringStatus status) throws CoreException {
        if (movedMember.wasPublic()) 
            return true; //Always ok if member was already public
        boolean ok = true;
        IJavaSearchScope scope= SearchEngine.createJavaSearchScope(new IJavaElement[] { javaProject });
        SearchPattern pattern= SearchPattern.createPattern(movedMember.getMember(), IJavaSearchConstants.REFERENCES);
        SearchEngine engine= new SearchEngine();
        final Set<SearchMatch> references = new HashSet<SearchMatch>();
        engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant()}, scope, new SearchRequestor() {
            @Override
            public void acceptSearchMatch(SearchMatch match) throws CoreException {
                if (match.getAccuracy() == SearchMatch.A_ACCURATE && !match.isInsideDocComment())
                    references.add(match);
            }
        }, new NullProgressMonitor());
        
        String referredPkg = getPackageName(targetAspect); // since the element is moved it's package *will* be...
        for (SearchMatch match : references) {
            if (match.getElement() instanceof IJavaElement) {
                IJavaElement referingElement = (IJavaElement) match.getElement();
                if (!isMoved(referingElement)) {
                    if (movedMember.wasPrivate()) {
                        ok = false;
                        if (isAllowMakePublic()) {
                            movedMember.addModifier(Modifier.PUBLIC);
                        }
                        else {
                            status.addWarning("The moved private member '"+movedMember.getElementName()+"' will not be accessible" +
                                    " after refactoring.",
                                    makeContext(match));
                        }
                    }
                    else if (movedMember.wasPackageVisible() || movedMember.wasProtected()) {
                        String referringPkg = getPackageName(referingElement);
                        if (referringPkg!=null && !referringPkg.equals(referredPkg)) {
                            ok = false;
                            if (isAllowMakePublic()) {
                                movedMember.addModifier(Modifier.PUBLIC);
                            }
                            else {
                                status.addWarning("The moved member '"+movedMember.getElementName()+"' may not be accessible " +
                                        "after refactoring",
                                        makeContext(match));
                            }
                        }
                    }
                }
            }
        }
        return ok;
    }

    /**
     * Retrieve package name of a IJavaElement.
     * @return The name of the package, or null if the IJavaElement is not nested inside a IPackagFragment.
     */
    private String getPackageName(IJavaElement el) {
        IPackageFragment pkg = (IPackageFragment) el.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
        if (pkg==null) return null;
        return pkg.getElementName();
    }

    @Override
    public RefactoringStatus checkInitialConditions(IProgressMonitor monitor)
            throws CoreException, OperationCanceledException {
        
        RefactoringStatus status= new RefactoringStatus();
        monitor.beginTask("Checking preconditions...", 1);
        try {
            if (memberMap == null || memberMap.isEmpty())
                status.merge(RefactoringStatus.createFatalErrorStatus("No pullout targets have been specified."));
            else {
                for (ICompilationUnit cu : memberMap.keySet()) {
                    for (IMember member : memberMap.get(cu)) {
                        if (!member.exists()) {
                            status.merge(RefactoringStatus.createFatalErrorStatus(
                                    MessageFormat.format("Member ''{0}'' does not exist.", 
                                            new Object[] { member.getElementName()})));
                        }
                        else if (!isInTopLevelType(member)) {
                            status.merge(RefactoringStatus.createFatalErrorStatus(
                                    MessageFormat.format("Member ''{0}'' is not directly nested in a top-level type.", 
                                            new Object[] { member.getElementName()})));
                        }
                        else if (member.isBinary()) {
                            status.merge(RefactoringStatus.createFatalErrorStatus(
                                    MessageFormat.format("Member ''{0}'' is not in source code. Binary methods can not be refactored.", 
                                            new Object[] { member.getElementName()})));
                        }
                        else if (!member.getCompilationUnit().isStructureKnown()) {
                            status.merge(RefactoringStatus.createFatalErrorStatus(
                                    MessageFormat.format("Compilation unit ''{0}'' contains compile errors.", 
                                            new Object[] { cu.getElementName()})));
                        }
                    }
                }
            }
        } finally {
            monitor.done();
        }
        return status;
    }
    
    private void checkOutgoingReferences(final ITDCreator itd, final RefactoringStatus status)
            throws CoreException, OperationCanceledException {
        if (willBePrivileged()) 
            return; //Always OK!
        
        // Walk the AST to find problematic references (e.g. references to private members from within the moved method)
        itd.getMemberNode().accept(new ASTVisitor() {
            /**
             * Check for various problems that may be caused by moving a reference into
             * a different context.
             */
            private void checkReference(ASTNode node, final IBinding binding, RefactoringStatus status) {
                if (isField(binding) || isMethod(binding) || isType(binding)) {
                    if (isTypeParameter(binding))
                        return; //Exclude these, or they'll look like package restricted types in code below.
                    if (isMoved(binding)) 
                        return; //OK: anything moved to the aspect will be accessible from the aspect
                    int mods = binding.getModifiers();
                    if (Modifier.isPrivate(mods)) {
                        status.addWarning("private member '"+binding.getName()+"' accessed and refactored aspect is not privileged",
                                makeContext(itd.getMember(), node));
                    }
                    if (JdtFlags.isProtected(binding) || JdtFlags.isPackageVisible(binding)) {
                        // FIXKDV: separate case for protected
                        // These are really two separate cases, but the cases where this matters (i.e.
                        // aspects that have a super type are rare so I'm not dealing with that
                        // right now (this is relatively harmless: will result in a spurious warning message 
                        // in rare case where the pulled member is protected and is pulled from target aspect's
                        // supertype that is not in the same package as target aspect)
                        String referredPkg = getPackageName(binding.getJavaElement());
                        if (referredPkg!=null) {
                            //If it has no package, we'll just ignore it, whatever it is, it's probably not subject to
                            // package scope :-)
                            String aspectPkg = targetAspect.getPackageFragment().getElementName();
                            if (!referredPkg.equals(aspectPkg)) {
                                String keyword = JdtFlags.isProtected(binding)?"protected":"package restricted";
                                status.addWarning(keyword+" member '"+binding.getName()+"' is accessed and refactored aspect is not privileged",
                                        makeContext(itd.getMember(), node));
                            }
                        }
                    }
                }
            }
            
            private boolean isField(IBinding binding) {
                return (binding instanceof IVariableBinding)
                    && ((IVariableBinding)binding).isField();
            }
            
            private boolean isMethod(IBinding binding) {
                return (binding instanceof IMethodBinding);
            }
            
            private boolean isType(IBinding binding) {
                return binding instanceof ITypeBinding;
            }
            
            private boolean isTypeParameter(IBinding binding) {
                return binding instanceof ITypeBinding
                  && (  ((ITypeBinding)binding).isCapture() 
                     || ((ITypeBinding)binding).isTypeVariable() );
            }
            
            @Override
            public boolean visit(SimpleName node) {
                IBinding binding = node.resolveBinding();
                checkReference(node, binding, status);
                return true;
            }

        });
    }

    private void clearMembers() {
        memberMap = new HashMap<ICompilationUnit, Collection<IMember>>();
        memberSet = new HashSet<IMember>();
        javaProject = null;
    }

    @Override
    public Change createChange(IProgressMonitor pm) throws CoreException,
            OperationCanceledException {
        try {
            pm.beginTask("Creating changes...", memberMap.keySet().size());
            CompositeChange allChanges = new CompositeChange("PullOut ITDs");
            for (ICompilationUnit cu : memberMap.keySet()) {
                
                // Prepare an ASTRewriter for this compilation unit
                ASTParser parser= ASTParser.newParser(AST.JLS8);
                parser.setSource(cu);
                ASTNode cuNode = parser.createAST(pm);
                MultiTextEdit cuEdits = new MultiTextEdit();

                // Apply all operations to the AST rewriter
                for (IMember member : getMembers(cu)) {
                    ISourceRange range = member.getSourceRange();
                    range = grabSpaceBefore(cu, range);
                    cuEdits.addChild(new DeleteEdit(range.getOffset(), range.getLength()));
                }

                // Create CUChange object with the accumulated deletion edits.
                CompilationUnitChange cuChanges = newCompilationUnitChange(cu);
                cuChanges.setEdit(cuEdits);
                
                // Add changes for this compilation unit.
                allChanges.add(cuChanges);
                
                pm.worked(1);
            }
            aspectChanges.rewriteAspect(pm, allChanges);
            return allChanges;
        }
        finally {
            pm.done();
        }
    }

    /**
     * For cosmetic reasons (nicer indentation of resulting text after deletion of membernode
     * we force the nodes sourcerange to include any spaces in front of the node, upto the 
     * beginning of the line.
     * @param cu 
     * @return 
     */
    private ISourceRange grabSpaceBefore(ICompilationUnit cu, ISourceRange range) {
        try {
            IBuffer sourceText = cu.getBuffer();
            int start = range.getOffset();
            int len = range.getLength();
            while (start>0 && isSpace(sourceText.getChar(start-1))) {
                start--; len++;
            }
            return new SourceRange(start, len);
        } catch (JavaModelException e) {
            //This operation is not essential, so it is fine if it silently fails.
            return range;
        }
    }

    private boolean isSpace(char c) {
        return c==' '||c=='\t';
    }

    private CompilationUnitChange newCompilationUnitChange(ICompilationUnit cu) {
        CompilationUnitChange cuChange = new CompilationUnitChange("PullOut ITDs", cu);
        if (targetAspect.getCompilationUnit()==cu) {
            //Also use this cuChange object for the aspect changes
            aspectChanges.setCUChange(cuChange);
        }
        return cuChange;
    }

    /**
     * @return The target aspect where we will create the intertype declarations.
     */
    public AspectElement getAspect() {
        return targetAspect;
    }

    public String getAspectName() {
        AspectElement theAspect = getAspect();
        if (theAspect==null) return "";
        return theAspect.getFullyQualifiedName();
    }

    /**
     * Compute the location where new ITDs will be inserted in the target aspect's source code.
     */
    private int getInsertLocation() {
        try {
            return  targetAspect.getSourceRange().getOffset()
                  + targetAspect.getSourceRange().getLength()-1;
        } catch (JavaModelException e) {
            return 0;
        }
    }

    IJavaProject getJavaProject() {
        return javaProject;
    }

    public IMember[] getMembers() {
        List<IMember> members = new ArrayList<IMember>();
        for (ICompilationUnit cu : memberMap.keySet()) {
            members.addAll(getMembers(cu));
        }
        return members.toArray(new IMember[members.size()]);
    }

    private Collection<IMember> getMembers(ICompilationUnit cu) {
        Collection<IMember> result = memberMap.get(cu);
        if (result==null) {
            result = new ArrayList<IMember>();
            memberMap.put(cu, result);
        }
        return result;
    }

    @Override
    public String getName() {
        return "Pull-Out";
    }
    
    public boolean hasMembers() {
        return !memberSet.isEmpty();
    }

    public RefactoringStatus initialize(Map<String, String> args) {
        RefactoringStatus status = new RefactoringStatus();
        setMakePrivileged(Boolean.valueOf(args.get(MAKE_PRIVILEGED)));
        setMember((IMember)JavaCore.create(args.get(MEMBER)), status);
        return status;
    }

    private boolean isInTopLevelType(IMember member) {
        IJavaElement parent = member.getParent();
        Assert.isTrue(parent.getElementType()==IJavaElement.TYPE); 
        return parent.getParent().getElementType()==IJavaElement.COMPILATION_UNIT;
    }
    
    /**
     * Is the "make privileged" option of the refactoring set.
     */
    public boolean isMakePrivileged() {
        return makePrivileged;
    }

    /**
     * Does given IBinding refer to an IJavaElement that will be moved into the Aspect?
     */
    private boolean isMoved(IBinding binding) {
        return isPulled(binding.getJavaElement());
    }

    /**
     * Will the given IJavaElement be moved into the Aspect? This test returns true, also for
     * IJavaElements that are contained inside pulled elements!
     */
    public boolean isMoved(IJavaElement javaElement) {
        //Null case is handled to easily terminate recursion
        return javaElement!=null
           && ( isPulled(javaElement) || isMoved(javaElement.getParent()) );
    }

    /**
     * Is the target aspect privileged before the refactoring?
     */
    private boolean isPrivileged() {
        if (targetAspect==null)
            return false;
        try {
            return targetAspect.isPrivileged();
        } catch (JavaModelException e) {
            return false;
        }
    }

    /**
     * Are we allowed to delete the abstract modifier and fabricate
     * dummy method bodies?
     */
    public boolean isGenerateAbstractMethodStubs() {
        return generateAbstractMethodStubs;
    }
    
    /**
     * Allow pulling out of abstract methods. The abstract keyword will
     * be removed and a dummy method body added.
     */
    public void setGenerateAbstractMethodStubs(boolean allow) {
        this.generateAbstractMethodStubs = allow;
    }

    /**
     * Allow ITDs to be made public, as needed.
     */
    public void setAllowMakePublic(boolean allow) {
        this.allowMakePublic = allow;
    }
    
    /**
     * Allow ITDs to be made public, as needed.
     */
    public void setAllowDeleteProtected(boolean allow) {
        this.allowDeleteProtected = allow;
    }
    
    /**
     * Are we allowed to delete any visibility modifier (on ITDs)
     * and make the ITD public?
     */
    public boolean isAllowMakePublic() {
        return allowMakePublic;
    }

    /**
     * Are we allowed to delete the protected keyword from ITDs?
     */
    public boolean isAllowDeleteProtected() {
        return allowDeleteProtected || allowMakePublic;
    }
    
    /**
     * Is the given IJaveElement selected to be pulled into the Aspect. Elements moved because they are 
     * nested inside selected elements are *not* considered (if you want this, use isMoved instead).
     */
    private boolean isPulled(IJavaElement javaElement) {
        return memberSet.contains(javaElement);
    }

    private static RefactoringStatusContext makeContext(ICompilationUnit cu, ASTNode node) {
        return JavaStatusContext.create(cu,
                    new SourceRange(node.getStartPosition(), node.getLength()));
    }

    private static RefactoringStatusContext makeContext(IMember member) {
        try {
            return JavaStatusContext.create(member.getCompilationUnit(), member.getSourceRange());
        } catch (JavaModelException e) {
            return null; // Too bad, no context for the error message
        }
    }

    static RefactoringStatusContext makeContext(IMember member, ASTNode node) {
        return makeContext(member.getCompilationUnit(), node);
    }

    private static RefactoringStatusContext makeContext(SearchMatch match) {
        try {
            IJavaElement element = (IJavaElement) match.getElement();
            ITypeRoot typeRoot = (ITypeRoot) element.getAncestor(IJavaElement.COMPILATION_UNIT);
            if (typeRoot==null) {
                typeRoot = (ITypeRoot) element.getAncestor(IJavaElement.CLASS_FILE);
            }
            ISourceRange range = new SourceRange(match.getOffset(), match.getLength());
            return JavaStatusContext.create(typeRoot, range);
        }
        catch (Throwable e) {
            return null;
        }
    }


    public void setAspect(AspectElement target) {
        this.targetAspect = target;
    }

    /**
     * Set the target aspect by giving the name of the aspect. Note that this method
     * only works if it can figure out what project to look for the aspect, so at least
     * one member to be pulled out has to be set prior to calling this method.
     */
    public RefactoringStatus setAspect(String name) {
        IType type= null;

        try {
            if (name.length() == 0)
                return RefactoringStatus.createFatalErrorStatus("Select an Aspect.");

            type= getJavaProject().findType(name, new NullProgressMonitor());
            if (type == null || !type.exists())
                return RefactoringStatus.createErrorStatus(MessageFormat.format("Aspect ''{0}'' does not exist.", name));
            if (!(type instanceof AspectElement))
                return RefactoringStatus.createErrorStatus(MessageFormat.format("''{0}'' is not an Aspect.", name));
        } catch (JavaModelException exception) {
            return RefactoringStatus.createFatalErrorStatus("Could not determine type.");
        }

        if (type.isReadOnly())
            return RefactoringStatus.createFatalErrorStatus("Type is read-only.");

        if (type.isBinary())
            return RefactoringStatus.createFatalErrorStatus("Type is binary.");
        
        targetAspect = (AspectElement) type;

        return new RefactoringStatus();
    }

    /**
     * Set the "make privileged" option of the refactoring.
     */
    public void setMakePrivileged(boolean makePrivileged) {
        this.makePrivileged = makePrivileged;
    }

    public void setMember(IMember member, RefactoringStatus status) {
        clearMembers();
        addMember(member, status);
    }

    /**
     * Will the target aspect be privileged after refactoring
     */
    public boolean willBePrivileged() {
        return isPrivileged() || isMakePrivileged();
    }

    protected String getAbstractMethodStubBody(IMember originalMember) {
        //FIXKDV: Stupid implementation for now... maybe we can use the Eclipse Java Code templates somehow
        // or have the user specify their own abstract method stub template in the wizard.
        return " { throw new Error(\"abstract method stub\"); }";
    }
}