/**

	 * Utility method that checks, if there is already a query with the same identifier.

	 * @param query

	 * @return a handle, that is not in conflict with any existed one in the system. If there were no 

	 * conflict in the beginning, then the query's own identifier is returned. If there were, then

	 * the suffix [x] is applied the query's identifier, where x is a number.

	 */

	public String resolveIdentifiersConflict(AbstractRepositoryQuery query) {

		String patternStr = "\\[(\\d+)\\]$"; // all string that end with [x], where x is a number

	    Pattern pattern = Pattern.compile(patternStr);

		// resolve name conflict

		Set<AbstractRepositoryQuery> existingQueries = getTaskList().getQueries();

		Map<String, AbstractRepositoryQuery> queryMap = new HashMap<String, AbstractRepositoryQuery>();

		for (AbstractRepositoryQuery existingQuery : existingQueries) {

			queryMap.put(existingQuery.getHandleIdentifier(), existingQuery);

		}

		// suggest a new handle if needed

		String handle = query.getHandleIdentifier();

		while (queryMap.get(handle) != null) {

			Matcher matcher = pattern.matcher(handle);

			boolean matchFound = matcher.find();

			if (matchFound) {

				// increment index

				int index = Integer.parseInt(matcher.group(1));

				index++;

				handle = matcher.replaceAll("[" + index + "]");

			} else {

				handle += "[1]";

			}

		}

		return handle;

	}

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

 * Copyright (c) 2004, 2007 Mylyn project committers 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

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

package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;

import org.eclipse.mylyn.monitor.core.StatusHandler;

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

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

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

import org.eclipse.ui.IViewActionDelegate;

import org.eclipse.ui.IViewPart;

import org.eclipse.ui.PlatformUI;

import org.w3c.dom.Document;

/**

 * Allow to clone a selected query.

 * 

 * @author Jevgeni Holodkov

 */

public class QueryCloneAction extends Action implements IViewActionDelegate {

	protected ISelection selection;

	public void init(IViewPart view) {

		// ignore

	}

	public void run(IAction action) {

		run(getSelectedQuery(selection));

	}

	public void selectionChanged(IAction action, ISelection selection) {

		this.selection = selection;

		AbstractRepositoryQuery selectedQuery = getSelectedQuery(selection);

		action.setEnabled(true);

		if (selectedQuery != null) {

			action.setEnabled(true);

		} else {

			action.setEnabled(false);

		}

	}

	protected AbstractRepositoryQuery getSelectedQuery(ISelection newSelection) {

		if (selection instanceof StructuredSelection) {

			// allow to select only one element

			if (((StructuredSelection) selection).size() == 1) {

				Object selectedObject = ((StructuredSelection) selection).getFirstElement();

				if (selectedObject instanceof AbstractRepositoryQuery) {

					return (AbstractRepositoryQuery) selectedObject;

				}

			}

		}

		return null;

	}

	public void run(AbstractRepositoryQuery selectedQuery) {

		if (selectedQuery == null) {

			MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),

					ITasksUiConstants.TITLE_DIALOG, "No query selected.");

			return;

		}

		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();

		queries.add(selectedQuery);

		Document queryDoc = TasksUiPlugin.getTaskListManager().getTaskListWriter().createQueryDocument(queries);

		List<AbstractRepositoryQuery> clonedQueries = TasksUiPlugin.getTaskListManager()

				.getTaskListWriter()

				.readQueryDocument(queryDoc);

		if (clonedQueries.size() > 0) {

			for (AbstractRepositoryQuery query : clonedQueries) {

				String handle = TasksUiPlugin.getTaskListManager().resolveIdentifiersConflict(query);

				query.setHandleIdentifier(handle);

				AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(query.getRepositoryKind());

				connectorUi.openEditQueryDialog(query);

			}

		} else {

			// cannot happen

			StatusHandler.fail(new IllegalStateException(selectedQuery.toString()), "Query cloning did not succeeded.", true);

			return;

		}

	}

}