import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;

import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;

import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;

import org.eclipse.mylyn.internal.context.ui.wizards.RetrieveLatestContextDialog;

import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;

//					boolean result = MessageDialog.openQuestion(WorkbenchUtil.getShell(),

//							Messages.ContextUiPlugin_Task_Activation,

//							Messages.ContextUiPlugin_No_local_task_context_exists);

//					if (result) {

//					ContextRetrieveWizard wizard = new ContextRetrieveWizard(task);

//					WizardDialog dialog = new WizardDialog(WorkbenchUtil.getShell(), wizard);

//					dialog.create();

//					dialog.setBlockOnOpen(true);

//					dialog.open();

//					new org.eclipse.mylyn.internal.context.ui.actions.ContextRetrieveAction().run(task);

//					}

//				}

//			}

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

 * Copyright (c) 2009 Tasktop Technologies 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:

 *     Tasktop Technologies - initial API and implementation

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

package org.eclipse.mylyn.internal.context.ui.wizards;

import java.lang.reflect.InvocationTargetException;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.layout.GridLayoutFactory;

import org.eclipse.jface.operation.IRunnableContext;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.operation.ModalContext;

import org.eclipse.jface.wizard.ProgressMonitorPart;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.mylyn.internal.provisional.commons.ui.WorkbenchUtil;

import org.eclipse.mylyn.internal.tasks.ui.util.AttachmentUtil;

import org.eclipse.mylyn.tasks.core.ITask;

import org.eclipse.mylyn.tasks.core.ITaskAttachment;

import org.eclipse.mylyn.tasks.core.TaskRepository;

import org.eclipse.mylyn.tasks.ui.TasksUi;

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.graphics.Cursor;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Link;

import org.eclipse.swt.widgets.Shell;

import com.ibm.icu.text.DateFormat;

/**

 * @author Steffen Pingel

 */

public class RetrieveLatestContextDialog extends MessageDialog {

	public static class ProgressContainer implements IRunnableContext {

		private static final String FOCUS_CONTROL = "focusControl"; //$NON-NLS-1$

		// The number of long running operation executed from the dialog.

		private long activeRunningOperations = 0;

		private Cursor arrowCursor;

		private Button cancelButton;

		private boolean lockedUI = false;

		private boolean needsProgressMonitor;

		// The progress monitor

		private final ProgressMonitorPart progressMonitorPart;

		private final Shell shell;

		private Cursor waitCursor;

		public ProgressContainer(Shell shell, ProgressMonitorPart progressMonitorPart) {

			this.shell = shell;

			this.progressMonitorPart = progressMonitorPart;

		}

		/**

		 * About to start a long running operation triggered through the wizard. Shows the progress monitor and disables

		 * the wizard's buttons and controls.

		 * 

		 * @param enableCancelButton

		 *            <code>true</code> if the Cancel button should be enabled, and <code>false</code> if it should be

		 *            disabled

		 * @return the saved UI state

		 */

		private Object aboutToStart(boolean enableCancelButton) {

			Map<Object, Object> savedState = null;

			if (getShell() != null) {

				// Save focus control

				Control focusControl = getShell().getDisplay().getFocusControl();

				if (focusControl != null && focusControl.getShell() != getShell()) {

					focusControl = null;

				}

				//cancelButton.removeSelectionListener(cancelListener);

				// Set the busy cursor to all shells.

				Display d = getShell().getDisplay();

				waitCursor = new Cursor(d, SWT.CURSOR_WAIT);

				setDisplayCursor(waitCursor);

				// Set the arrow cursor to the cancel component.

				arrowCursor = new Cursor(d, SWT.CURSOR_ARROW);

				cancelButton.setCursor(arrowCursor);

				// Deactivate shell

				savedState = new HashMap<Object, Object>(10);

				saveUiState(savedState);

				if (focusControl != null) {

					savedState.put(FOCUS_CONTROL, focusControl);

				}

				// Attach the progress monitor part to the cancel button

				progressMonitorPart.attachToCancelComponent(cancelButton);

				progressMonitorPart.setVisible(true);

			}

			return savedState;

		}

		public Button getCancelButton() {

			return cancelButton;

		}

		private IProgressMonitor getProgressMonitor() {

			return progressMonitorPart;

		}

		public Shell getShell() {

			return shell;

		}

		public boolean isActive() {

			return activeRunningOperations > 0;

		}

		protected void restoreUiState(Map<Object, Object> state) {

			// ignore

		}

		/**

		 * This implementation of IRunnableContext#run(boolean, boolean, IRunnableWithProgress) blocks until the

		 * runnable has been run, regardless of the value of <code>fork</code>. It is recommended that <code>fork</code>

		 * is set to true in most cases. If <code>fork</code> is set to <code>false</code>, the runnable will run in the

		 * UI thread and it is the runnable's responsibility to call <code>Display.readAndDispatch()</code> to ensure UI

		 * responsiveness. UI state is saved prior to executing the long-running operation and is restored after the

		 * long-running operation completes executing. Any attempt to change the UI state of the wizard in the

		 * long-running operation will be nullified when original UI state is restored.

		 */

		public void run(boolean fork, boolean cancelable, IRunnableWithProgress runnable)

				throws InvocationTargetException, InterruptedException {

			// The operation can only be canceled if it is executed in a separate

			// thread.

			// Otherwise the UI is blocked anyway.

			Object state = null;

			if (activeRunningOperations == 0) {

				state = aboutToStart(fork && cancelable);

			}

			activeRunningOperations++;

			try {

				if (!fork) {

					lockedUI = true;

				}

				ModalContext.run(runnable, fork, getProgressMonitor(), getShell().getDisplay());

				lockedUI = false;

			} finally {

				activeRunningOperations--;

				// Stop if this is the last one

				if (state != null) {

					stopped(state);

				}

			}

		}

		protected void saveUiState(Map<Object, Object> savedState) {

			// ignore

		}

		public void setCancelButton(Button cancelButton) {

			this.cancelButton = cancelButton;

		}

		/**

		 * Sets the given cursor for all shells currently active for this window's display.

		 * 

		 * @param c

		 *            the cursor

		 */

		private void setDisplayCursor(Cursor c) {

			Shell[] shells = getShell().getDisplay().getShells();

			for (Shell shell2 : shells) {

				shell2.setCursor(c);

			}

		}

		/**

		 * A long running operation triggered through the wizard was stopped either by user input or by normal end.

		 * Hides the progress monitor and restores the enable state wizard's buttons and controls.

		 * 

		 * @param savedState

		 *            the saved UI state as returned by <code>aboutToStart</code>

		 * @see #aboutToStart

		 */

		@SuppressWarnings("unchecked")

		private void stopped(Object savedState) {

			if (getShell() != null && !getShell().isDisposed()) {

				if (needsProgressMonitor) {

					progressMonitorPart.setVisible(false);

					progressMonitorPart.removeFromCancelComponent(cancelButton);

				}

				Map<Object, Object> state = (Map<Object, Object>) savedState;

				restoreUiState(state);

//				cancelButton.addSelectionListener(cancelListener);

				setDisplayCursor(null);

				cancelButton.setCursor(null);

				waitCursor.dispose();

				waitCursor = null;

				arrowCursor.dispose();

				arrowCursor = null;

				Control focusControl = (Control) state.get(FOCUS_CONTROL);

				if (focusControl != null && !focusControl.isDisposed()) {

					focusControl.setFocus();

				}

			}

		}

	}

	public static boolean openQuestion(Shell shell, ITask task) {

		String title = "Task Activation";

		TaskRepository repository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),

				task.getRepositoryUrl());

		List<ITaskAttachment> contextAttachments = AttachmentUtil.getContextAttachments(repository, task);

		Collections.sort(contextAttachments, new TaskAttachmentComparator());

		if (contextAttachments.size() > 0) {

			ITaskAttachment attachment = contextAttachments.get(0);

			String author = null;

			if (attachment.getAuthor() != null) {

				author = (attachment.getAuthor().getName()) != null ? attachment.getAuthor().getName()

						: attachment.getAuthor().getPersonId();

			}

			if (author == null) {

				author = "<Unknown>";

			}

			Date date = attachment.getCreationDate();

			String dateString = null;

			if (date != null) {

				dateString = DateFormat.getDateInstance(DateFormat.LONG).format(date);

			}

			if (dateString == null) {

				dateString = "<Unkown>";

			}

			String message = NLS.bind(

					"No local context exists. Retrieve latest context created by {0} on {1} from repository?", author,

					dateString);

			int kind = QUESTION;

			int style = SWT.NONE;

			RetrieveLatestContextDialog dialog = new RetrieveLatestContextDialog(shell, title, null, message, kind,

					new String[] { IDialogConstants.OK_LABEL, IDialogConstants.CANCEL_LABEL }, 0, task, attachment);

			style &= SWT.SHEET;

			dialog.setShellStyle(dialog.getShellStyle() | style);

			return dialog.open() == 0;

		}

		return false;

	}

	private final ITaskAttachment attachment;

	private Link link;

	private ProgressContainer progressContainer;

	private ProgressMonitorPart progressMonitorPart;

	private final ITask task;

	public RetrieveLatestContextDialog(Shell parentShell, String dialogTitle, Image dialogTitleImage,

			String dialogMessage, int dialogImageType, String[] dialogButtonLabels, int defaultIndex, ITask task,

			ITaskAttachment attachment) {

		super(parentShell, dialogTitle, dialogTitleImage, dialogMessage, dialogImageType, dialogButtonLabels,

				defaultIndex);

		this.task = task;

		this.attachment = attachment;

	}

	@Override

	protected void buttonPressed(int buttonId) {

		if (progressContainer.isActive()) {

			return;

		}

		if (buttonId == 0) {

			if (!AttachmentUtil.downloadContext(task, attachment, progressContainer)) {

				// failed

				return;

			}

		}

		super.buttonPressed(buttonId);

	}

	@Override

	protected Control createButtonBar(Composite parent) {

		Composite composite = new Composite(parent, SWT.NONE);

		composite.setLayout(GridLayoutFactory.fillDefaults().numColumns(3).create());

		GridDataFactory.fillDefaults().grab(true, false).span(2, 1).applyTo(composite);

		Control control = createLink(composite);

		GridDataFactory.fillDefaults().grab(true, false).applyTo(control);

		super.createButtonBar(composite);

		return composite;

	}

	@Override

	protected Control createContents(Composite parent) {

		Control control = super.createContents(parent);

		progressContainer.setCancelButton(getButton(1));

		getButton(0).setFocus();

		return control;

	}

	@Override

	protected Control createCustomArea(Composite parent) {

		progressMonitorPart = new ProgressMonitorPart(parent, null);

		GridDataFactory.fillDefaults().grab(true, false).applyTo(progressMonitorPart);

		progressContainer = new ProgressContainer(getShell(), progressMonitorPart) {

			@Override

			protected void restoreUiState(Map<Object, Object> state) {

				link.setEnabled(true);

				getButton(0).setEnabled(true);

				getButton(1).setEnabled(true);

			};

			@Override

			protected void saveUiState(Map<Object, Object> savedState) {

				link.setEnabled(false);

				getButton(0).setEnabled(false);

			};

		};

		return progressMonitorPart;

	}

	protected Control createLink(Composite parent) {

		link = new Link(parent, SWT.NONE);

		link.setText("<a>Select Context from History</a>");

		link.addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				close();

				ContextRetrieveWizard wizard = new ContextRetrieveWizard(task);

				WizardDialog dialog = new WizardDialog(WorkbenchUtil.getShell(), wizard);

				dialog.create();

				dialog.setBlockOnOpen(true);

				setReturnCode(dialog.open());

			}

		});

		return link;

	}

}

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

 * Copyright (c) 2009 Tasktop Technologies 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:

 *     Tasktop Technologies - initial API and implementation

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

package org.eclipse.mylyn.internal.context.ui.wizards;

import java.util.Comparator;

import java.util.Date;

import org.eclipse.mylyn.tasks.core.ITaskAttachment;

class TaskAttachmentComparator implements Comparator<ITaskAttachment> {

	public int compare(ITaskAttachment attachment1, ITaskAttachment attachment2) {

		Date created1 = null;

		Date created2 = null;

		created1 = attachment1.getCreationDate();

		created2 = attachment2.getCreationDate();

		if (created1 != null && created2 != null) {

			return (-1) * created1.compareTo(created2);

		} else if (created1 == null && created2 != null) {

			return 1;

		} else if (created1 != null && created2 == null) {

			return -1;

		} else {

			return 0;

		}

	}

}