/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.eclipse.org/org/documents/epl-v10.php
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.ide.eclipse.adt.internal.refactorings.core;

import static com.android.SdkConstants.ANDROID_PREFIX;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_ID;
import static com.android.SdkConstants.ATTR_NAME;
import static com.android.SdkConstants.ATTR_TYPE;
import static com.android.SdkConstants.DOT_XML;
import static com.android.SdkConstants.EXT_XML;
import static com.android.SdkConstants.FD_RES;
import static com.android.SdkConstants.FN_RESOURCE_CLASS;
import static com.android.SdkConstants.NEW_ID_PREFIX;
import static com.android.SdkConstants.PREFIX_RESOURCE_REF;
import static com.android.SdkConstants.PREFIX_THEME_REF;
import static com.android.SdkConstants.R_CLASS;
import static com.android.SdkConstants.TAG_ITEM;
import static com.android.SdkConstants.TOOLS_URI;

import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.AdtUtils;
import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo;
import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper;
import com.android.ide.eclipse.adt.internal.resources.ResourceNameValidator;
import com.android.ide.eclipse.adt.internal.sdk.ProjectState;
import com.android.ide.eclipse.adt.internal.sdk.Sdk;
import com.android.resources.ResourceFolderType;
import com.android.resources.ResourceType;
import com.android.utils.SdkUtils;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.internal.corext.refactoring.rename.RenameFieldProcessor;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CompositeChange;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.TextChange;
import org.eclipse.ltk.core.refactoring.TextFileChange;
import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext;
import org.eclipse.ltk.core.refactoring.participants.RenameParticipant;
import org.eclipse.ltk.core.refactoring.participants.RenameRefactoring;
import org.eclipse.ltk.core.refactoring.resource.RenameResourceChange;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * A rename participant handling renames of resources (such as R.id.foo and R.layout.bar).
 * This reacts to refactorings of fields in the R inner classes (such as R.id), and updates
 * the XML files as appropriate; renaming .xml files, updating XML attributes, resource
 * references in style declarations, and so on.
 */
@SuppressWarnings("restriction") // WTP API
public class RenameResourceParticipant extends RenameParticipant {
    /** The project we're refactoring in */
    private @NonNull IProject mProject;

    /** The type of the resource we're refactoring, such as {@link ResourceType#ID} */
    private @NonNull ResourceType mType;
    /**
     * The type of the resource folder we're refactoring in, such as
     * {@link ResourceFolderType#VALUES}. When refactoring non value files, we need to
     * rename the files as well.
     */
    private @NonNull ResourceFolderType mFolderType;

    /** The previous name of the resource */
    private @NonNull String mOldName;

    /** The new name of the resource */
    private @NonNull String mNewName;

    /** Whether references to the resource should be updated */
    private boolean mUpdateReferences;

    /** A match pattern to look for in XML, such as {@code @attr/foo} */
    private @NonNull String mXmlMatch1;

    /** A match pattern to look for in XML, such as {@code ?attr/foo} */
    private @Nullable String mXmlMatch2;

    /** A match pattern to look for in XML, such as {@code ?foo} */
    private @Nullable String mXmlMatch3;

    /** The value to replace a reference to {@link #mXmlMatch1} with, such as {@code @attr/bar} */
    private @NonNull String mXmlNewValue1;

    /** The value to replace a reference to {@link #mXmlMatch2} with, such as {@code ?attr/bar} */
    private @Nullable String mXmlNewValue2;

    /** The value to replace a reference to {@link #mXmlMatch3} with, such as {@code ?bar} */
    private @Nullable String mXmlNewValue3;

    /**
     * If non null, this refactoring was initiated as a file rename of an XML file (and if
     * null, we are just reacting to a Java field rename)
     */
    private IFile mRenamedFile;

    /**
     * If renaming a field, we need to create an embedded field refactoring to update the
     * Java sources referring to the corresponding R class field. This is stored as an
     * instance such that we can have it participate in both the condition check methods
     * as well as the {@link #createChange(IProgressMonitor)} refactoring operation.
     */
    private RenameRefactoring mFieldRefactoring;

    /**
     * Set while we are creating an embedded Java refactoring. This could cause a recursive
     * invocation of the XML renaming refactoring to react to the field, so this is flag
     * during the call to the Java processor, and is used to ignore requests for adding in
     * field reactions during that time.
     */
    private static boolean sIgnore;

    /**
     * Creates a new {@linkplain RenameResourceParticipant}
     */
    public RenameResourceParticipant() {
    }

    @Override
    public String getName() {
        return "Android Rename Field Participant";
    }

    @Override
    protected boolean initialize(Object element) {
        if (sIgnore) {
            return false;
        }

        if (element instanceof IField) {
            IField field = (IField) element;
            IType declaringType = field.getDeclaringType();
            if (declaringType != null) {
                if (R_CLASS.equals(declaringType.getParent().getElementName())) {
                    String typeName = declaringType.getElementName();
                    mType = ResourceType.getEnum(typeName);
                    if (mType != null) {
                        mUpdateReferences = getArguments().getUpdateReferences();
                        mFolderType = AdtUtils.getFolderTypeFor(mType);
                        IJavaProject javaProject = (IJavaProject) field.getAncestor(
                                IJavaElement.JAVA_PROJECT);
                        mProject = javaProject.getProject();
                        mOldName = field.getElementName();
                        mNewName = getArguments().getNewName();
                        mFieldRefactoring = null;
                        mRenamedFile = null;
                        createXmlSearchPatterns();
                        return true;
                    }
                }
            }

            return false;
        } else if (element instanceof IFile) {
            IFile file = (IFile) element;
            mProject = file.getProject();
            if (BaseProjectHelper.isAndroidProject(mProject)) {
                IPath path = file.getFullPath();
                int segments = path.segmentCount();
                if (segments == 4 && path.segment(1).equals(FD_RES)) {
                    String parentName = file.getParent().getName();
                    mFolderType = ResourceFolderType.getFolderType(parentName);
                    if (mFolderType != null && mFolderType != ResourceFolderType.VALUES) {
                        mType = AdtUtils.getResourceTypeFor(mFolderType);
                        if (mType != null) {
                            mUpdateReferences = getArguments().getUpdateReferences();
                            mProject = file.getProject();
                            mOldName = AdtUtils.stripAllExtensions(file.getName());
                            mNewName = AdtUtils.stripAllExtensions(getArguments().getNewName());
                            mRenamedFile = file;
                            createXmlSearchPatterns();

                            mFieldRefactoring = null;
                            IField field = getResourceField(mProject, mType, mOldName);
                            if (field != null) {
                                mFieldRefactoring = createFieldRefactoring(field);
                            } else {
                                // no corresponding field; aapt has not run yet. Perhaps user has
                                // turned off auto build.
                                mFieldRefactoring = null;
                            }

                            return true;
                        }
                    }
                }
            }
        } else if (element instanceof String) {
            String uri = (String) element;
            if (uri.startsWith(PREFIX_RESOURCE_REF) && !uri.startsWith(ANDROID_PREFIX)) {
                RenameResourceProcessor processor = (RenameResourceProcessor) getProcessor();
                mProject = processor.getProject();
                mType = processor.getType();
                mFolderType = AdtUtils.getFolderTypeFor(mType);
                mOldName = processor.getCurrentName();
                mNewName = processor.getNewName();
                assert uri.endsWith(mOldName) && uri.contains(mType.getName()) : uri;
                mUpdateReferences = getArguments().getUpdateReferences();
                if (mNewName.isEmpty()) {
                    mUpdateReferences = false;
                }
                mRenamedFile = null;
                createXmlSearchPatterns();
                mFieldRefactoring = null;
                if (!mNewName.isEmpty()) {
                    IField field = getResourceField(mProject, mType, mOldName);
                    if (field != null) {
                        mFieldRefactoring = createFieldRefactoring(field);
                    }
                }

                return true;
            }
        }

        return false;
    }

    /** Create nested Java refactoring which updates the R field references, if applicable */
    private RenameRefactoring createFieldRefactoring(IField field) {
        return createFieldRefactoring(field, mNewName, mUpdateReferences);
    }

    /**
     * Create nested Java refactoring which updates the R field references, if
     * applicable
     *
     * @param field the field to be refactored
     * @param newName the new name
     * @param updateReferences whether references should be updated
     * @return a new rename refactoring
     */
    public static RenameRefactoring createFieldRefactoring(
            @NonNull IField field,
            @NonNull String newName,
            boolean updateReferences) {
        RenameFieldProcessor processor = new RenameFieldProcessor(field);
        processor.setRenameGetter(false);
        processor.setRenameSetter(false);
        RenameRefactoring refactoring = new RenameRefactoring(processor);
        processor.setUpdateReferences(updateReferences);
        processor.setUpdateTextualMatches(false);
        processor.setNewElementName(newName);
        try {
            if (refactoring.isApplicable()) {
                return refactoring;
            }
        } catch (CoreException e) {
            AdtPlugin.log(e, null);
        }

        return null;
    }

    private void createXmlSearchPatterns() {
        // Set up search strings for the attribute iterator. This will
        // identify string matches for mXmlMatch1, 2 and 3, and when matched,
        // will add a replacement edit for mXmlNewValue1, 2, or 3.
        mXmlMatch2 = null;
        mXmlNewValue2 = null;
        mXmlMatch3 = null;
        mXmlNewValue3 = null;

        String typeName = mType.getName();
        if (mUpdateReferences) {
            mXmlMatch1 = PREFIX_RESOURCE_REF + typeName + '/' + mOldName;
            mXmlNewValue1 = PREFIX_RESOURCE_REF + typeName + '/' + mNewName;
            if (mType == ResourceType.ID) {
                mXmlMatch2 = NEW_ID_PREFIX + mOldName;
                mXmlNewValue2 = NEW_ID_PREFIX + mNewName;
            } else if (mType == ResourceType.ATTR) {
                // When renaming @attr/foo, also edit ?attr/foo
                mXmlMatch2 = PREFIX_THEME_REF + typeName + '/' + mOldName;
                mXmlNewValue2 = PREFIX_THEME_REF + typeName + '/' + mNewName;
                // as well as ?foo
                mXmlMatch3 = PREFIX_THEME_REF + mOldName;
                mXmlNewValue3 = PREFIX_THEME_REF + mNewName;
            }
        } else if (mType == ResourceType.ID) {
            mXmlMatch1 = NEW_ID_PREFIX + mOldName;
            mXmlNewValue1 = NEW_ID_PREFIX + mNewName;
        }
    }

    @Override
    public RefactoringStatus checkConditions(IProgressMonitor pm, CheckConditionsContext context)
            throws OperationCanceledException {
        if (mRenamedFile != null && getArguments().getNewName().indexOf('.') == -1
                && mRenamedFile.getName().indexOf('.') != -1) {
            return RefactoringStatus.createErrorStatus(
                    String.format("You must include the file extension (%1$s?)",
                           mRenamedFile.getName().substring(mRenamedFile.getName().indexOf('.'))));
        }

        // Ensure that the new name is valid
        if (mNewName != null && !mNewName.isEmpty()) {
            ResourceNameValidator validator = ResourceNameValidator.create(false, mProject, mType);
            String error = validator.isValid(mNewName);
            if (error != null) {
                return RefactoringStatus.createErrorStatus(error);
            }
        }

        if (mFieldRefactoring != null) {
            try {
                sIgnore = true;
                return mFieldRefactoring.checkAllConditions(pm);
            } catch (CoreException e) {
                AdtPlugin.log(e, null);
            } finally {
                sIgnore = false;
            }
        }

        return new RefactoringStatus();
    }

    @Override
    public Change createChange(IProgressMonitor monitor) throws CoreException,
            OperationCanceledException {
        if (monitor.isCanceled()) {
            return null;
        }

        CompositeChange result = new CompositeChange("Update resource references");

        // Only show the children in the refactoring preview dialog
        result.markAsSynthetic();

        addResourceFileChanges(result, mProject, monitor);

        // If renaming resources in a library project, also offer to rename references
        // in including projects
        if (mUpdateReferences) {
            ProjectState projectState = Sdk.getProjectState(mProject);
            if (projectState != null && projectState.isLibrary()) {
                List<ProjectState> parentProjects = projectState.getParentProjects();
                for (ProjectState state : parentProjects) {
                    IProject project = state.getProject();
                    CompositeChange nested = new CompositeChange(
                            String.format("Update references in %1$s", project.getName()));
                    addResourceFileChanges(nested, project, monitor);
                    if (nested.getChildren().length > 0) {
                        result.add(nested);
                    }
                }
            }
        }

        if (mFieldRefactoring != null) {
            // We have to add in Java field refactoring
            try {
                sIgnore = true;
                addJavaChanges(result, monitor);
            } finally {
                sIgnore = false;
            }
        } else {
            // Disable field refactoring added by the default Java field rename handler
            disableExistingResourceFileChange();
        }

        return (result.getChildren().length == 0) ? null : result;
    }

    /**
     * Adds all changes to resource files (typically XML but also renaming drawable files
     *
     * @param project the Android project
     * @param className the layout classes
     */
    private void addResourceFileChanges(
            CompositeChange change,
            IProject project,
            IProgressMonitor monitor)
            throws OperationCanceledException {
        if (monitor.isCanceled()) {
            return;
        }

        try {
            // Update resource references in the manifest
            IFile manifest = project.getFile(SdkConstants.ANDROID_MANIFEST_XML);
            if (manifest != null) {
                addResourceXmlChanges(manifest, change, null);
            }

            // Update references in XML resource files
            IFolder resFolder = project.getFolder(SdkConstants.FD_RESOURCES);

            IResource[] folders = resFolder.members();
            for (IResource folder : folders) {
                if (!(folder instanceof IFolder)) {
                    continue;
                }
                String folderName = folder.getName();
                ResourceFolderType folderType = ResourceFolderType.getFolderType(folderName);
                IResource[] files = ((IFolder) folder).members();
                for (int i = 0; i < files.length; i++) {
                    IResource member = files[i];
                    if ((member instanceof IFile) && member.exists()) {
                        IFile file = (IFile) member;
                        String fileName = member.getName();

                        if (SdkUtils.endsWith(fileName, DOT_XML)) {
                            addResourceXmlChanges(file, change, folderType);
                        }

                        if ((mRenamedFile == null || !mRenamedFile.equals(file))
                                && fileName.startsWith(mOldName)
                                && fileName.length() > mOldName.length()
                                && fileName.charAt(mOldName.length()) == '.'
                                && mFolderType != ResourceFolderType.VALUES
                                && mFolderType == folderType) {
                            // Rename this file
                            String newFile = mNewName + fileName.substring(mOldName.length());
                            IPath path = file.getFullPath();
                            change.add(new RenameResourceChange(path, newFile));
                        }
                    }
                }
            }
        } catch (CoreException e) {
            RefactoringUtil.log(e);
        }
    }

    private void addJavaChanges(CompositeChange result, IProgressMonitor monitor)
            throws CoreException, OperationCanceledException {
        if (monitor.isCanceled()) {
            return;
        }

        RefactoringStatus status = mFieldRefactoring.checkAllConditions(monitor);
        if (status != null && !status.hasError()) {
            Change fieldChanges = mFieldRefactoring.createChange(monitor);
            if (fieldChanges != null) {
                result.add(fieldChanges);

                // Look for the field change on the R.java class; it's a derived file
                // and will generate file modified manually warnings. Disable it.
                disableRClassChanges(fieldChanges);
            }
        }
    }

    private boolean addResourceXmlChanges(
            IFile file,
            CompositeChange changes,
            ResourceFolderType folderType) {
        IModelManager modelManager = StructuredModelManager.getModelManager();
        IStructuredModel model = null;
        try {
            model = modelManager.getExistingModelForRead(file);
            if (model == null) {
                model = modelManager.getModelForRead(file);
            }
            if (model != null) {
                IStructuredDocument document = model.getStructuredDocument();
                if (model instanceof IDOMModel) {
                    IDOMModel domModel = (IDOMModel) model;
                    Element root = domModel.getDocument().getDocumentElement();
                    if (root != null) {
                        List<TextEdit> edits = new ArrayList<TextEdit>();
                        addReplacements(edits, root, document, folderType);
                        if (!edits.isEmpty()) {
                            MultiTextEdit rootEdit = new MultiTextEdit();
                            rootEdit.addChildren(edits.toArray(new TextEdit[edits.size()]));
                            TextFileChange change = new TextFileChange(file.getName(), file);
                            change.setTextType(EXT_XML);
                            change.setEdit(rootEdit);
                            changes.add(change);
                        }
                    }
                } else {
                    return false;
                }
            }

            return true;
        } catch (IOException e) {
            AdtPlugin.log(e, null);
        } catch (CoreException e) {
            AdtPlugin.log(e, null);
        } finally {
            if (model != null) {
                model.releaseFromRead();
            }
        }

        return false;
    }

    private void addReplacements(
            @NonNull List<TextEdit> edits,
            @NonNull Element element,
            @NonNull IStructuredDocument document,
            @Nullable ResourceFolderType folderType) {
        String tag = element.getTagName();
        if (folderType == ResourceFolderType.VALUES) {
            // Look for
            //   <item name="main_layout" type="layout">...</item>
            //   <item name="myid" type="id"/>
            //   <string name="mystring">...</string>
            // etc
            if (tag.equals(mType.getName())
                    || (tag.equals(TAG_ITEM)
                            && (mType == ResourceType.ID
                                || mType.getName().equals(element.getAttribute(ATTR_TYPE))))) {
                Attr nameNode = element.getAttributeNode(ATTR_NAME);
                if (nameNode != null && nameNode.getValue().equals(mOldName)) {
                    int start = RefactoringUtil.getAttributeValueRangeStart(nameNode, document);
                    if (start != -1) {
                        int end = start + mOldName.length();
                        edits.add(new ReplaceEdit(start, end - start, mNewName));
                    }
                }
            }
        }

        NamedNodeMap attributes = element.getAttributes();
        for (int i = 0, n = attributes.getLength(); i < n; i++) {
            Attr attr = (Attr) attributes.item(i);
            String value = attr.getValue();

            // If not updating references, only update XML matches that define the id
            if (!mUpdateReferences && (!ATTR_ID.equals(attr.getLocalName()) ||
                    !ANDROID_URI.equals(attr.getNamespaceURI()))) {

                if (TOOLS_URI.equals(attr.getNamespaceURI()) && value.equals(mXmlMatch1)) {
                    int start = RefactoringUtil.getAttributeValueRangeStart(attr, document);
                    if (start != -1) {
                        int end = start + mXmlMatch1.length();
                        edits.add(new ReplaceEdit(start, end - start, mXmlNewValue1));
                    }
                }

                continue;
            }

            // Replace XML attribute reference, such as
            //   android:id="@+id/oldName"   =>   android:id="+id/newName"

            String match = null;
            String matchedValue = null;

            if (value.equals(mXmlMatch1)) {
                match = mXmlMatch1;
                matchedValue = mXmlNewValue1;
            } else if (value.equals(mXmlMatch2)) {
                match = mXmlMatch2;
                matchedValue = mXmlNewValue2;
            } else if (value.equals(mXmlMatch3)) {
                match = mXmlMatch3;
                matchedValue = mXmlNewValue3;
            } else {
                continue;
            }

            if (match != null) {
                if (mNewName.isEmpty() && ATTR_ID.equals(attr.getLocalName()) &&
                        ANDROID_URI.equals(attr.getNamespaceURI())) {
                    // Delete attribute
                    IndexedRegion region = (IndexedRegion) attr;
                    int start = region.getStartOffset();
                    int end = region.getEndOffset();
                    edits.add(new ReplaceEdit(start, end - start, ""));
                } else {
                    int start = RefactoringUtil.getAttributeValueRangeStart(attr, document);
                    if (start != -1) {
                        int end = start + match.length();
                        edits.add(new ReplaceEdit(start, end - start, matchedValue));
                    }
                }
            }
        }

        NodeList children = element.getChildNodes();
        for (int i = 0, n = children.getLength(); i < n; i++) {
            Node child = children.item(i);
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                addReplacements(edits, (Element) child, document, folderType);
            } else if (child.getNodeType() == Node.TEXT_NODE && mUpdateReferences) {
                // Replace XML text, such as @color/custom_theme_color in
                //    <item name="android:windowBackground">@color/custom_theme_color</item>
                //
                String text = child.getNodeValue();
                int index = getFirstNonBlankIndex(text);
                if (index != -1) {
                    String match = null;
                    String matchedValue = null;
                    if (mXmlMatch1 != null
                            && text.startsWith(mXmlMatch1) && text.trim().equals(mXmlMatch1)) {
                        match = mXmlMatch1;
                        matchedValue = mXmlNewValue1;
                    } else if (mXmlMatch2 != null
                            && text.startsWith(mXmlMatch2) && text.trim().equals(mXmlMatch2)) {
                        match = mXmlMatch2;
                        matchedValue = mXmlNewValue2;
                    } else if (mXmlMatch3 != null
                            && text.startsWith(mXmlMatch3) && text.trim().equals(mXmlMatch3)) {
                        match = mXmlMatch3;
                        matchedValue = mXmlNewValue3;
                    }
                    if (match != null) {
                        IndexedRegion region = (IndexedRegion) child;
                        int start = region.getStartOffset() + index;
                        int end = start + match.length();
                        edits.add(new ReplaceEdit(start, end - start, matchedValue));
                    }
                }
            }
        }
    }

    /**
     * Returns the index of the first non-space character in the string, or -1
     * if the string is empty or has only whitespace
     *
     * @param s the string to check
     * @return the index of the first non whitespace character
     */
    private int getFirstNonBlankIndex(String s) {
        for (int i = 0, n = s.length(); i < n; i++) {
            if (!Character.isWhitespace(s.charAt(i))) {
                return i;
            }
        }

        return -1;
    }

    /**
     * Initiates a renaming of a resource item
     *
     * @param project the project containing the resource references
     * @param type the type of resource
     * @param name the name of the resource
     * @return false if initiating the rename failed
     */
    @Nullable
    private static IField getResourceField(
            @NonNull IProject project,
            @NonNull ResourceType type,
            @NonNull String name) {
        try {
            IJavaProject javaProject = BaseProjectHelper.getJavaProject(project);
            if (javaProject == null) {
                return null;
            }

            String pkg = ManifestInfo.get(project).getPackage();
            // TODO: Rename in all libraries too?
            IType t = javaProject.findType(pkg + '.' + R_CLASS + '.' + type.getName());
            if (t == null) {
                return null;
            }

            return t.getField(name);
        } catch (CoreException e) {
            AdtPlugin.log(e, null);
        }

        return null;
    }

    /**
     * Searches for existing changes in the refactoring which modifies the R
     * field to rename it. it's derived so performing this change will generate
     * a "generated code was modified manually" warning
     */
    private void disableExistingResourceFileChange() {
        IFolder genFolder = mProject.getFolder(SdkConstants.FD_GEN_SOURCES);
        if (genFolder != null && genFolder.exists()) {
            ManifestInfo manifestInfo = ManifestInfo.get(mProject);
            String pkg = manifestInfo.getPackage();
            if (pkg != null) {
                IFile rFile = genFolder.getFile(pkg.replace('.', '/') + '/' + FN_RESOURCE_CLASS);
                TextChange change = getTextChange(rFile);
                if (change != null) {
                    change.setEnabled(false);
                }
            }
        }
    }

    /**
     * Searches for existing changes in the refactoring which modifies the R
     * field to rename it. it's derived so performing this change will generate
     * a "generated code was modified manually" warning
     *
     * @param change the change to disable R file changes in
     */
    public static void disableRClassChanges(Change change) {
        if (change.getName().equals(FN_RESOURCE_CLASS)) {
            change.setEnabled(false);
        }
        // Look for the field change on the R.java class; it's a derived file
        // and will generate file modified manually warnings. Disable it.
        if (change instanceof CompositeChange) {
            for (Change outer : ((CompositeChange) change).getChildren()) {
                disableRClassChanges(outer);
            }
        }
    }
}