/*******************************************************************************
 * Copyright (c) 2000, 2005 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.ui.actions;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceRuleFactory;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.MultiRule;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;

/**
 * Standard action for deleting the currently selected resources.
 * <p>
 * This class may be instantiated; it is not intended to be subclassed.
 * </p>
 */
public class DeleteResourceAction extends SelectionListenerAction {

    static class DeleteProjectDialog extends MessageDialog {

        private IResource[] projects;

        private boolean deleteContent = false;
        
        /**
         * Control testing mode.  In testing mode, it returns true to
         * delete contents and does not pop up the dialog.
         */
        private boolean fIsTesting = false;

        private Button radio1;

        private Button radio2;

        DeleteProjectDialog(Shell parentShell, IResource[] projects) {
            super(parentShell, getTitle(projects), null, // accept the default window icon
                    getMessage(projects), MessageDialog.QUESTION, new String[] {
                            IDialogConstants.YES_LABEL,
                            IDialogConstants.NO_LABEL }, 0); // yes is the default
            this.projects = projects;
        }

        static String getTitle(IResource[] projects) {
            if (projects.length == 1)
                return IDEWorkbenchMessages.DeleteResourceAction_titleProject1;
            return IDEWorkbenchMessages.DeleteResourceAction_titleProjectN;
        }

        static String getMessage(IResource[] projects) {
            if (projects.length == 1) {
                IProject project = (IProject) projects[0];
                return NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_confirmProject1, project.getName());
            }
            return NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_confirmProjectN, new Integer(projects.length));
        }

        /* (non-Javadoc)
         * Method declared on Window.
         */
        protected void configureShell(Shell newShell) {
            super.configureShell(newShell);
            PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell,
                    IIDEHelpContextIds.DELETE_PROJECT_DIALOG);
        }

        protected Control createCustomArea(Composite parent) {
            Composite composite = new Composite(parent, SWT.NONE);
            composite.setLayout(new GridLayout());
            radio1 = new Button(composite, SWT.RADIO);
            radio1.addSelectionListener(selectionListener);
            String text1;
            if (projects.length == 1) {
                IProject project = (IProject) projects[0];
                if (project == null || project.getLocation() == null)
                    text1 = IDEWorkbenchMessages.DeleteResourceAction_deleteContentsN;
                else
                    text1 = NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_deleteContents1, project.getLocation().toOSString());
            } else {
                text1 = IDEWorkbenchMessages.DeleteResourceAction_deleteContentsN;
            }
            radio1.setText(text1);
            radio1.setFont(parent.getFont());

            radio2 = new Button(composite, SWT.RADIO);
            radio2.addSelectionListener(selectionListener);
            String text2 = IDEWorkbenchMessages.DeleteResourceAction_doNotDeleteContents;
            radio2.setText(text2);
            radio2.setFont(parent.getFont());

            // set initial state
            radio1.setSelection(deleteContent);
            radio2.setSelection(!deleteContent);

            return composite;
        }

        private SelectionListener selectionListener = new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                Button button = (Button) e.widget;
                if (button.getSelection()) {
                    deleteContent = (button == radio1);
                }
            }
        };

        boolean getDeleteContent() {
            return deleteContent;
        }

		/* (non-Javadoc)
		 * @see org.eclipse.jface.window.Window#open()
		 */
		public int open() {
			//Override Window#open() to allow for non-interactive testing.
			if (fIsTesting) {
				deleteContent = true;
				return Window.OK;
			}
			return super.open();
		}
        
		/**
		 * Set this delete dialog into testing mode.  It won't pop up, 
		 * and it returns true for deleteContent.
		 * 
		 * @param t the testing mode
		 */
        void setTestingMode(boolean t) {
        	fIsTesting = t;
        }
    }

    /**
     * The id of this action.
     */
    public static final String ID = PlatformUI.PLUGIN_ID
            + ".DeleteResourceAction";//$NON-NLS-1$

    /**
     * The shell in which to show any dialogs.
     */
    private Shell shell;

    /**
     * Whether or not we are deleting content for projects.
     */
    private boolean deleteContent = false;

    /**
     * Whether or not to automatically delete out of sync resources
     */
    private boolean forceOutOfSyncDelete = false;
    
    /**
     * Flag that allows testing mode ... it won't pop up the project
     * delete dialog, and will return "delete all content".
     */
    protected boolean fTestingMode = false;

    /**
     * Creates a new delete resource action.
     *
     * @param shell the shell for any dialogs
     */
    public DeleteResourceAction(Shell shell) {
        super(IDEWorkbenchMessages.DeleteResourceAction_text);
        setToolTipText(IDEWorkbenchMessages.DeleteResourceAction_toolTip);
        PlatformUI.getWorkbench().getHelpSystem().setHelp(this,
				IIDEHelpContextIds.DELETE_RESOURCE_ACTION);
        setId(ID);
        if (shell == null) {
            throw new IllegalArgumentException();
        }
        this.shell = shell;
    }

    /**
     * Returns whether delete can be performed on the current selection.
     *
     * @param resources the selected resources
     * @return <code>true</code> if the resources can be deleted, and 
     *  <code>false</code> if the selection contains non-resources or phantom
     *  resources
     */
    private boolean canDelete(IResource[] resources) {
        // allow only projects or only non-projects to be selected; 
        // note that the selection may contain multiple types of resource
        if (!(containsOnlyProjects(resources) || containsOnlyNonProjects(resources))) {
            return false;
        }

        if (resources.length == 0)
            return false;
        // Return true if everything in the selection exists.
        for (int i = 0; i < resources.length; i++) {
            IResource resource = resources[i];
            if (resource.isPhantom()) {
                return false;
            }
        }
        return true;
    }

    /**
     * Returns whether the selection contains linked resources.
     *
     * @param resources the selected resources
     * @return <code>true</code> if the resources contain linked   
     *  resources, and <code>false</code> otherwise
     */
    private boolean containsLinkedResource(IResource[] resources) {
        for (int i = 0; i < resources.length; i++) {
            IResource resource = resources[i];
            if (resource.isLinked())
                return true;
        }
        return false;
    }

    /**
     * Returns whether the selection contains only non-projects.
     *
     * @param resources the selected resources
     * @return <code>true</code> if the resources contains only non-projects, and 
     *  <code>false</code> otherwise
     */
    private boolean containsOnlyNonProjects(IResource[] resources) {
        int types = getSelectedResourceTypes(resources);
        // check for empty selection
        if (types == 0)
            return false;
        // note that the selection may contain multiple types of resource
        return (types & IResource.PROJECT) == 0;
    }

    /**
     * Returns whether the selection contains only projects.
     * 
     * @param resources the selected resources
     * @return <code>true</code> if the resources contains only projects, and 
     *  <code>false</code> otherwise
     */
    private boolean containsOnlyProjects(IResource[] resources) {
        int types = getSelectedResourceTypes(resources);
        // note that the selection may contain multiple types of resource
        return types == IResource.PROJECT;
    }
    
    /**
     * Creates and returns a result status appropriate for the given list of exceptions.
     * @param exceptions The list of exceptions that occurred (may be empty)
     * @return The result status for the deletion
     */
    private IStatus createResult(List exceptions) {
    	if (exceptions.isEmpty())
    		return Status.OK_STATUS;
        final int exceptionCount = exceptions.size();
        if (exceptionCount == 1) {
            return ((CoreException) exceptions.get(0)).getStatus();
        }
        CoreException[] children = (CoreException[]) exceptions.toArray(new CoreException[exceptionCount]);
        boolean outOfSync = false;
        for (int i = 0; i < children.length; i++) {
            if (children[i].getStatus().getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) {
                outOfSync = true;
                break;
            }
        }
        String title = outOfSync ? IDEWorkbenchMessages.DeleteResourceAction_outOfSyncError : IDEWorkbenchMessages.DeleteResourceAction_deletionExceptionMessage;
        final MultiStatus multi = new MultiStatus(
                IDEWorkbenchPlugin.IDE_WORKBENCH,
                0,
                title, null);
        for (int i = 0; i < exceptionCount; i++) {
            CoreException exception = children[i];
            IStatus status = exception.getStatus();
            multi.add(new Status(status.getSeverity(), status.getPlugin(),
                    status.getCode(), status.getMessage(), exception));
        }
        return multi;
    }

    /**
     * Asks the user to confirm a delete operation.
     *
     * @param resources the selected resources
     * @return <code>true</code> if the user says to go ahead, and <code>false</code>
     *  if the deletion should be abandoned
     */
    private boolean confirmDelete(IResource[] resources) {
        if (containsOnlyProjects(resources)) {
            return confirmDeleteProjects(resources);
        }
        return confirmDeleteNonProjects(resources);
    }

    /**
     * Asks the user to confirm a delete operation,
     * where the selection contains no projects.
     *
     * @param resources the selected resources
     * @return <code>true</code> if the user says to go ahead, and <code>false</code>
     *  if the deletion should be abandoned
     */
    private boolean confirmDeleteNonProjects(IResource[] resources) {
        String title;
        String msg;
        if (resources.length == 1) {
            title = IDEWorkbenchMessages.DeleteResourceAction_title1;
            IResource resource = resources[0];
            if (resource.isLinked())
                msg = NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_confirmLinkedResource1, resource.getName());
            else
                msg = NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_confirm1, resource.getName());
        } else {
            title = IDEWorkbenchMessages.DeleteResourceAction_titleN;
            if (containsLinkedResource(resources))
                msg = NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_confirmLinkedResourceN, new Integer(resources.length));
            else
                msg = NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_confirmN, new Integer(resources.length));
        }
        return MessageDialog.openQuestion(shell, title, msg);
    }

    /**
     * Asks the user to confirm a delete operation,
     * where the selection contains only projects.
     * Also remembers whether project content should be deleted.
     *
     * @param resources the selected resources
     * @return <code>true</code> if the user says to go ahead, and <code>false</code>
     *  if the deletion should be abandoned
     */
    private boolean confirmDeleteProjects(IResource[] resources) {
        DeleteProjectDialog dialog = new DeleteProjectDialog(shell, resources);
        dialog.setTestingMode(fTestingMode);
        int code = dialog.open();
        deleteContent = dialog.getDeleteContent();
        return code == 0; // YES
    }

    /**
     * Deletes the given resources.
     */
    private void delete(IResource[] resourcesToDelete, IProgressMonitor monitor) throws CoreException{
        final List exceptions = new ArrayList();
        forceOutOfSyncDelete = false;
        monitor.beginTask("", resourcesToDelete.length); //$NON-NLS-1$
        try {
	        for (int i = 0; i < resourcesToDelete.length; ++i) {
	            if (monitor.isCanceled()) {
	                throw new OperationCanceledException();
	            }
	            try {
	                delete(resourcesToDelete[i], new SubProgressMonitor(monitor, 1,
	                        SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK));
	            } catch (CoreException e) {
	                exceptions.add(e);
	            }
	        }
	        IStatus result = createResult(exceptions);
			if (!result.isOK())
				throw new CoreException(result);
        } finally {
        	monitor.done();
        }
    }

    /**
     * Deletes the given resource.
     */
    private void delete(IResource resourceToDelete, IProgressMonitor monitor)
            throws CoreException {
        boolean force = false; // don't force deletion of out-of-sync resources
        try {
            if (resourceToDelete.getType() == IResource.PROJECT) {
                // if it's a project, ask whether content should be deleted too
                IProject project = (IProject) resourceToDelete;
                project.delete(deleteContent, force, monitor);
            } else {
                // if it's not a project, just delete it
                resourceToDelete.delete(IResource.KEEP_HISTORY, monitor);
            }
        } catch (CoreException exception) {
            if (resourceToDelete.getType() == IResource.FILE) {
                IStatus[] children = exception.getStatus().getChildren();

                if (children.length == 1
                        && children[0].getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) {
                    if (forceOutOfSyncDelete) {
                        resourceToDelete.delete(IResource.KEEP_HISTORY
                                | IResource.FORCE, monitor);
                    } else {
                        int result = queryDeleteOutOfSync(resourceToDelete);

                        if (result == IDialogConstants.YES_ID) {
                            resourceToDelete.delete(IResource.KEEP_HISTORY
                                    | IResource.FORCE, monitor);
                        } else if (result == IDialogConstants.YES_TO_ALL_ID) {
                            forceOutOfSyncDelete = true;
                            resourceToDelete.delete(IResource.KEEP_HISTORY
                                    | IResource.FORCE, monitor);
                        } else if (result == IDialogConstants.CANCEL_ID) {
                            throw new OperationCanceledException();
                        }
                    }
                } else {
                    throw exception;
                }
            } else {
                throw exception;
            }
        }
    }

    /**
     * Return an array of the currently selected resources.
     *
     * @return the selected resources
     */
    private IResource[] getSelectedResourcesArray() {
        List selection = getSelectedResources();
        IResource[] resources = new IResource[selection.size()];
        selection.toArray(resources);
        return resources;
    }

    /**
     * Returns a bit-mask containing the types of resources in the selection.
     * 
     * @param resources the selected resources
     */
    private int getSelectedResourceTypes(IResource[] resources) {
        int types = 0;
        for (int i = 0; i < resources.length; i++) {
            types |= resources[i].getType();
        }
        return types;
    }

    /* (non-Javadoc)
     * Method declared on IAction.
     */
    public void run() {
        IResource[] resources = getSelectedResourcesArray();
        // WARNING: do not query the selected resources more than once
        // since the selection may change during the run, 
        // e.g. due to window activation when the prompt dialog is dismissed.
        // For more details, see Bug 60606 [Navigator] (data loss) Navigator deletes/moves the wrong file
        if (!confirmDelete(resources))
            return;
        final IResource[] resourcesToDelete = getResourcesToDelete(resources);

        if (resourcesToDelete.length == 0)
            return;
		//use a non-workspace job with a runnable inside so we can avoid periodic updates
    	Job deleteJob = new Job(IDEWorkbenchMessages.DeleteResourceAction_jobName) {
    		public IStatus run(IProgressMonitor monitor) {
				try {
					ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
						public void run(IProgressMonitor monitor) throws CoreException {
					        delete(resourcesToDelete, monitor);
						}
					},	null, IWorkspace.AVOID_UPDATE, monitor);
				} catch (CoreException e) {
					return e.getStatus();
				}
				return Status.OK_STATUS;
    		}

			/* (non-Javadoc)
			 * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
			 */
			public boolean belongsTo(Object family) {
				if (IDEWorkbenchMessages.DeleteResourceAction_jobName
						.equals(family)) {
					return true;
				}
				return super.belongsTo(family);
			}
    		
    	};
    	deleteJob.setRule(getDeleteRule(resourcesToDelete));
    	deleteJob.setUser(true);
    	deleteJob.schedule();
    }

    /*
     * Return the scheduling rule that encompasses the deletion of the selected resources
     */
    private ISchedulingRule getDeleteRule(IResource[] resourcesToDelete) {
        IResourceRuleFactory ruleFactory = ResourcesPlugin.getWorkspace().getRuleFactory();
        ISchedulingRule combinedRule = null;
        for (int i = 0; i < resourcesToDelete.length; i++) {
            IResource resource = resourcesToDelete[i];
            ISchedulingRule deleteRule = ruleFactory.deleteRule(resource);
            if (combinedRule == null) {
                combinedRule = deleteRule;
            } else {
                combinedRule = MultiRule.combine(combinedRule, deleteRule);
            }
        }
        return combinedRule;
    }

    /**
     * Returns the resources to delete based on the selection and their read-only status.
     * 
     * @param resources the selected resources
     * @return the resources to delete
     */
    private IResource[] getResourcesToDelete(IResource[] resources) {

        if (containsOnlyProjects(resources) && !deleteContent) {
            // We can just return the selection
            return resources;
        }

        ReadOnlyStateChecker checker = new ReadOnlyStateChecker(this.shell,
                IDEWorkbenchMessages.DeleteResourceAction_title1,
                IDEWorkbenchMessages.DeleteResourceAction_readOnlyQuestion);
        checker.setIgnoreLinkedResources(true);
        return checker.checkReadOnlyResources(resources);
    }

    /**
     * The <code>DeleteResourceAction</code> implementation of this
     * <code>SelectionListenerAction</code> method disables the action
     * if the selection contains phantom resources or non-resources
     */
    protected boolean updateSelection(IStructuredSelection selection) {
        return super.updateSelection(selection)
                && canDelete(getSelectedResourcesArray());
    }

    /**
     * Ask the user whether the given resource should be deleted
     * despite being out of sync with the file system.
     * @param resource the out of sync resource
     * @return One of the IDialogConstants constants indicating which
     * 	of the Yes, Yes to All, No, Cancel options has been selected by 
     * 	the user.
     */
    private int queryDeleteOutOfSync(IResource resource) {
        final MessageDialog dialog = new MessageDialog(
                shell,
                IDEWorkbenchMessages.DeleteResourceAction_messageTitle,
                null,
                NLS.bind(IDEWorkbenchMessages.DeleteResourceAction_outOfSyncQuestion, resource.getName()),
                MessageDialog.QUESTION, new String[] {
                        IDialogConstants.YES_LABEL,
                        IDialogConstants.YES_TO_ALL_LABEL,
                        IDialogConstants.NO_LABEL,
                        IDialogConstants.CANCEL_LABEL }, 0);
        shell.getDisplay().syncExec(new Runnable() {
            public void run() {
                dialog.open();
            }
        });
        int result = dialog.getReturnCode();
        if (result == 0)
            return IDialogConstants.YES_ID;
        if (result == 1)
            return IDialogConstants.YES_TO_ALL_ID;
        if (result == 2)
            return IDialogConstants.NO_ID;
        return IDialogConstants.CANCEL_ID;
    }
}