/*******************************************************************************

 * Copyright (c) 2007, 2008 IBM Corporation 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:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.ltk.core.refactoring.resource;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.ltk.core.refactoring.Change;

import org.eclipse.ltk.core.refactoring.ChangeDescriptor;

import org.eclipse.ltk.internal.core.refactoring.Messages;

import org.eclipse.ltk.internal.core.refactoring.RefactoringCoreMessages;

/**

 * {@link Change} that updates project references.

 * 

 * @since 3.6

 */

public class RenameProjectReferenceChange extends ResourceChange {

	private final String fProjectName;

	private final String fOldReference;

	private final String fNewReference;

	private final long fStampToRestore;

	private ChangeDescriptor fDescriptor;

	/**

	 * Creates the change.

	 * 

	 * @param projectName the name of the project to update

	 * @param oldReference the name of the old reference

	 * @param newReference the name of the new reference

	 */

	public RenameProjectReferenceChange(String projectName,

			String oldReference, String newReference) {

		this(projectName, oldReference, newReference, IResource.NULL_STAMP);

	}

	/**

	 * Creates the change with a time stamp to restore.

	 * 

	 * @param projectName the name of the project to update

	 * @param oldReference the name of the old reference

	 * @param newReference the name of the new reference

	 * @param stampToRestore the time stamp to restore or {@link IResource#NULL_STAMP} to not restore the

	 * time stamp.

	 */

	protected RenameProjectReferenceChange(String projectName,

			String oldReference, String newReference, long stampToRestore) {

		if (isEmpty(projectName) || isEmpty(oldReference)

				|| isEmpty(newReference)) {

			throw new IllegalArgumentException();

		}

		fProjectName= projectName;

		fOldReference= oldReference;

		fNewReference= newReference;

		fStampToRestore= stampToRestore;

		fDescriptor= null;

		setValidationMethod(VALIDATE_NOT_DIRTY);

	}

	/**

	 * @param s string to check

	 * @return true if the specified string null or empty and false otherwise

	 */

	private static boolean isEmpty(String s) {

		return s == null || s.length() == 0;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ltk.core.refactoring.Change#getDescriptor()

	 */

	public ChangeDescriptor getDescriptor() {

		return fDescriptor;

	}

	/**

	 * Sets the change descriptor to be returned by {@link Change#getDescriptor()}.

	 *

	 * @param descriptor the change descriptor

	 */

	public void setDescriptor(ChangeDescriptor descriptor) {

		fDescriptor= descriptor;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ltk.core.refactoring.resource.ResourceChange#getModifiedResource()

	 */

	protected IResource getModifiedResource() {

		return getProject();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ltk.core.refactoring.Change#getName()

	 */

	public String getName() {

		return Messages.format(RefactoringCoreMessages.RenameProjectReferenceChange_name, fProjectName);

	}

	/**

	 * Return the new reference name

	 * 

	 * @return return the new reference name

	 */

	public String getNewReference() {

		return fNewReference;

	}

	/**

	 * Return the old reference name

	 * 

	 * @return return the old reference name

	 */

	public String getOldReference() {

		return fOldReference;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.ltk.core.refactoring.Change#perform(org.eclipse.core.runtime.IProgressMonitor)

	 */

	public Change perform(IProgressMonitor pm) throws CoreException {

		try {

			pm.beginTask(Messages.format(RefactoringCoreMessages.RenameProjectReferenceChange_progress_description, fProjectName), 2);

			IProject project= getProject();

			long currentStamp= project.getModificationStamp();

			if (fStampToRestore != IResource.NULL_STAMP) {

				project.revertModificationStamp(fStampToRestore);

			}

			IProjectDescription description= project.getDescription();

			List newProjects= new ArrayList();

			IProject[] oldProjects= description.getReferencedProjects();

			for (int i= 0; i < oldProjects.length; i++) {

				IProject oldProject= oldProjects[i];

				if (oldProject.getName().equals(fOldReference)) {

					IProject newProject= ResourcesPlugin.getWorkspace()

							.getRoot().getProject(fNewReference);

					newProjects.add(newProject);

				} else {

					newProjects.add(oldProject);

				}

			}

			description.setReferencedProjects((IProject[])newProjects

					.toArray(new IProject[newProjects.size()]));

			pm.worked(1);

			project.setDescription(description, IResource.FORCE,

					new SubProgressMonitor(pm, 1));

			return new RenameProjectReferenceChange(fProjectName,

					fNewReference, fOldReference, currentStamp);

		} finally {

			pm.done();

		}

	}

	private IProject getProject() {

		return ResourcesPlugin.getWorkspace().getRoot()

				.getProject(fProjectName);

	}

}

	public static String RenameProjectReferenceChange_name;

	public static String RenameProjectReferenceChange_progress_description;

	public static String RenameResourceProcessor_update_references_change_name;

RenameProjectReferenceChange_name=Update ''{0}'' project references

RenameProjectReferenceChange_progress_description=Update ''{0}'' project references

RenameResourceProcessor_update_references_change_name=Update referencing projects

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.ltk.core.refactoring.CompositeChange;

import org.eclipse.ltk.core.refactoring.resource.RenameProjectReferenceChange;

			pm.worked(1);

			IProject[] projects= getReferencingProjects();

			if (projects.length > 0) {

				for (int i= 0; i < projects.length; i++) {

					IFile descriptor = projects[i].getFile(IProjectDescription.DESCRIPTION_FILE_NAME);

					deltaFactory.change(descriptor);

				}

			}

			pm.worked(1);

			if (isUpdateReferences()) {

				IProject[] projects= getReferencingProjects();

				if (projects.length > 0) {

					CompositeChange root= new CompositeChange(change.getName());

					root.markAsSynthetic();

					root.add(change);

					root.add(createUpdateReferencesChange(projects));

					return root;

				}

			}

	private Change createUpdateReferencesChange(IProject[] projects) {

		String oldName= getResource().getName();

		String newName= getNewResourceName();

		CompositeChange updateReferencesChange= new CompositeChange(

				RefactoringCoreMessages.RenameResourceProcessor_update_references_change_name);

		for (int i= 0; i < projects.length; i++) {

			RenameProjectReferenceChange change= new RenameProjectReferenceChange(

					projects[i].getName(), oldName, newName);

			updateReferencesChange.add(change);

		}

		return updateReferencesChange;

	}

	/**

	 * If processed resource is a project this method return projects which refer to this one.

	 * Otherwise it return empty list

	 * 

	 * @return list of the referencing projects

	 */

	private IProject[] getReferencingProjects() {

		if (!(getResource() instanceof IProject)) {

			return new IProject[0];

		}

		String name= getResource().getName();

		IProject[] allProjects= ResourcesPlugin.getWorkspace().getRoot()

				.getProjects();

		List projects= new ArrayList(allProjects.length);

		for (int i= 0; i < allProjects.length; i++) {

			IProject project= allProjects[i];

			if (project.exists() && project.isOpen()) {

				try {

					IProjectDescription descriptor= project.getDescription();

					IProject[] referencedProjects= descriptor

							.getReferencedProjects();

					for (int j= 0; j < referencedProjects.length; j++) {

						if (name.equals(referencedProjects[j].getName())) {

							projects.add(project);

						}

					}

				} catch (Exception e) {

					// ignore problem projects

				}

			}

		}

		return (IProject[])projects.toArray(new IProject[projects.size()]);

	}

	public static String RenameResourceWizard_update_references_field_label;

RenameResourceWizard_update_references_field_label=Update &references

import org.eclipse.swt.widgets.Button;

import org.eclipse.core.resources.IProject;

		private Button fUpdateReferencesField;

			if (isNeedReferenceUpdate()) {

				fUpdateReferencesField= new Button(composite, SWT.CHECK);

				fUpdateReferencesField.setText(RefactoringUIMessages.RenameResourceWizard_update_references_field_label);

				fUpdateReferencesField.setSelection(fRefactoringProcessor

						.isUpdateReferences());

				fUpdateReferencesField.setLayoutData(new GridData(GridData.FILL,

						GridData.BEGINNING, true, false, 2, 1));

			}

		protected boolean isNeedReferenceUpdate() {

			//only project have references

			return fRefactoringProcessor.getResource() instanceof IProject;

		}

			if (fUpdateReferencesField != null) {

				fRefactoringProcessor.setUpdateReferences(fUpdateReferencesField

						.getSelection());

			}