/*******************************************************************************
 * Copyright (c) 2009, 2019 Xored Software Inc 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
 * https://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     Xored Software Inc - initial API and implementation and/or initial documentation
 *******************************************************************************/
package org.eclipse.rcptt.core.workspace;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.rcptt.core.IQ7Extension;
import org.eclipse.rcptt.core.Q7Features;
import org.eclipse.rcptt.core.model.IContext;
import org.eclipse.rcptt.core.model.IElementChangedListener;
import org.eclipse.rcptt.core.model.IQ7Element;
import org.eclipse.rcptt.core.model.IQ7Folder;
import org.eclipse.rcptt.core.model.IQ7Model;
import org.eclipse.rcptt.core.model.IQ7NamedElement;
import org.eclipse.rcptt.core.model.IQ7Project;
import org.eclipse.rcptt.core.model.IQ7ProjectMetadata;
import org.eclipse.rcptt.core.model.ITestCase;
import org.eclipse.rcptt.core.model.ITestSuite;
import org.eclipse.rcptt.core.model.IVerification;
import org.eclipse.rcptt.core.model.ModelException;
import org.eclipse.rcptt.core.model.Q7ElementChangedEvent;
import org.eclipse.rcptt.core.model.search.Q7SearchCore;
import org.eclipse.rcptt.core.nature.RcpttNature;
import org.eclipse.rcptt.core.scenario.CapabilityContext;
import org.eclipse.rcptt.core.scenario.CapabilityContextItem;
import org.eclipse.rcptt.core.scenario.GroupContext;
import org.eclipse.rcptt.core.scenario.NamedElement;
import org.eclipse.rcptt.core.scenario.ScenarioFactory;
import org.eclipse.rcptt.core.scenario.SuperContext;
import org.eclipse.rcptt.core.scenario.TestSuiteItem;
import org.eclipse.rcptt.core.scenario.UnresolvedContext;
import org.eclipse.rcptt.core.scenario.UnresolvedVerification;
import org.eclipse.rcptt.core.scenario.WorkbenchContext;
import org.eclipse.rcptt.internal.core.Q7ExtensionManager;
import org.eclipse.rcptt.internal.core.RcpttPlugin;
import org.eclipse.rcptt.internal.core.model.ModelManager;
import org.eclipse.rcptt.internal.core.model.Q7Folder;
import org.eclipse.rcptt.internal.core.model.Q7InternalContext;
import org.eclipse.rcptt.internal.core.model.Q7InternalVerification;
import org.eclipse.rcptt.internal.core.model.Q7Model;
import org.eclipse.rcptt.tesla.internal.core.TeslaCore;
import org.osgi.framework.Bundle;
import org.osgi.framework.Version;

public class RcpttCore {

	public static final double SCENARIO_VERSION = 3.0;

	public static final String DEFAULT_WORKBENCH_CONTEXT_ID = "close.modal.dialogs";

	private static RcpttCore instance;

	public static synchronized RcpttCore getInstance() {
		if (instance == null) {
			Bundle bundle = Platform.getBundle("org.eclipse.core.resources");
			if (bundle == null) {
				RcpttPlugin.log(
						"There is no resources support. Q7Core could not be initialized...",
						null);
				return null;
			}
			instance = new RcpttCore();

			IQ7Extension[] exts = Q7ExtensionManager.getInstance().getExtensions();
			for (IQ7Extension ext : exts) {
				ext.initialize();
			}
		}
		return instance;
	}

	public static Version getPlatformVersion() {
		return TeslaCore.getPlatformVersion();
	}

	/**
	 * Returns an array of all contexts contained in the given scenario or context, or an empty array if the element is
	 * neither a scenario nor a context.
	 */
	public IContext[] getContexts(IQ7NamedElement element, IWorkspaceFinder finder, boolean ignoreErrors) {
		if (element instanceof ITestCase) {
			return getContexts((ITestCase) element, finder, ignoreErrors);
		} else if (element instanceof IContext) {
			return getContexts((IContext) element, finder, ignoreErrors);
		} else {
			return new IContext[0];
		}
	}

	/**
	 * Returns an array of all contexts contained in the given scenario or context, or an empty array if the element is
	 * neither a scenario nor a context.
	 */
	public IContext[] getContexts(IQ7NamedElement element, IWorkspaceFinder finder, boolean ignoreErrors,
			String capability) {
		if (element instanceof ITestCase) {
			return getContexts((ITestCase) element, finder, ignoreErrors);
		} else if (element instanceof IContext) {
			return getContexts((IContext) element, finder, ignoreErrors, capability);
		} else {
			return new IContext[0];
		}
	}

	/**
	 * Returns an array of all contexts contained in the given scenario, or an empty array in case of an error.
	 */
	public IContext[] getContexts(ITestCase scenario, IWorkspaceFinder finder, boolean ignoreErrors) {
		return getContexts(scenario, finder, ignoreErrors, null);
	}

	/**
	 * Returns an array of all contexts contained in the given scenario, or an empty array in case of an error.
	 */
	public IContext[] getContexts(ITestCase scenario, IWorkspaceFinder finder,
			boolean ignoreErrors, String capability) {
		try {
			String[] contexts = Q7SearchCore.findContextsByDocument(scenario);
			if (contexts == null) {
				contexts = scenario.getContexts();
			}
			return getContexts(scenario, Arrays.asList(contexts), finder, ignoreErrors, capability);
		} catch (ModelException e) {
			RcpttPlugin.log(e);
			return new IContext[0];
		}
	}

	/**
	 * Returns an array of all child contexts. If the given context is neither a super context nor a group context, then
	 * it doesn't have any children and an empty array is returned.
	 */
	public IContext[] getContexts(IContext context, IWorkspaceFinder finder, boolean ignoreErrors) {
		return getContexts(context, getContextReferences(context), finder, ignoreErrors);
	}

	/**
	 * Returns an array of all child contexts. If the given context is neither a super context nor a group context, then
	 * it doesn't have any children and an empty array is returned.
	 */
	public IContext[] getContexts(IContext context, IWorkspaceFinder finder, boolean ignoreErrors, String capability) {
		return getContexts(context, getContextReferences(context, capability), finder, ignoreErrors);
	}

	public IContext[] getContexts(IQ7NamedElement element, List<String> contextIds,
			IWorkspaceFinder finder, boolean ignoreErrors) {
		return getContexts(element, contextIds, finder, ignoreErrors, null);
	}

	public IContext[] getContexts(IQ7NamedElement element, List<String> contextIds,
			IWorkspaceFinder finder, boolean ignoreErrors, String capability) {
		if (finder == null) {
			finder = WorkspaceFinder.getInstance();
		}
		List<IContext> contexts = new ArrayList<IContext>();
		Set<String> projectContexts = new HashSet<String>();
		// Add project related contexts
		try {
			if (element instanceof ITestCase) {
				IQ7Project project = element.getQ7Project();
				IQ7ProjectMetadata metadata = project == null ? null : project.getMetadata();
				if (metadata != null && metadata.exists()) {
					String[] ctxs = metadata.getContexts();
					if (ctxs != null) {
						for (String ctx : ctxs) {
							IContext result = findContext(element, ignoreErrors, ctx,
									finder);
							if (result != null) {
								if (result.getNamedElement() instanceof CapabilityContext) {
									List<IContext> subcontexts = processedCapabilityContext(element, finder,
											ignoreErrors, capability,
											(CapabilityContext) result.getNamedElement());
									for (IContext context : subcontexts) {
										contexts.add(context);
										projectContexts.add(context.getID());
									}
								} else {
									contexts.add(result);
									projectContexts.add(result.getID());
								}
							}
						}
					}
				}
			}
		} catch (ModelException e) {
			RcpttPlugin.log(e);
		}

		for (String contextId : contextIds) {
			if (projectContexts.contains(contextId)) {
				continue;
			}
			IContext result = findContext(element, ignoreErrors, contextId, finder);
			if (result != null) {
				try {
					if (result.getNamedElement() instanceof CapabilityContext) {
						List<IContext> subcontexts = processedCapabilityContext(element, finder, ignoreErrors,
								capability, (CapabilityContext) result.getNamedElement());
						contexts.addAll(subcontexts);

					} else {
						contexts.add(result);
					}
				} catch (ModelException e) {
					RcpttPlugin.log(e);
				}
			}
		}

		// Add close modal dialogs context as first
		addDefaultContext(contexts);
		return contexts.toArray(new IContext[contexts.size()]);
	}

	private List<IContext> processedCapabilityContext(IQ7NamedElement element, IWorkspaceFinder finder,
			boolean ignoreErrors, String capability, CapabilityContext context) throws ModelException {
		for (CapabilityContextItem item : context.getItems()) {
			if (item.getCapability().contains(capability)) {
				final List<IContext> result = new ArrayList<IContext>();
				for (String id : item.getContextReferences()) {
					IContext subcontext = findContext(element, ignoreErrors, id, finder);
					if (subcontext != null) {
						if (subcontext.getNamedElement() instanceof CapabilityContext) {
							List<IContext> subcontexts = processedCapabilityContext(element, finder, ignoreErrors,
									capability, (CapabilityContext) subcontext.getNamedElement());
							result.addAll(subcontexts);
						} else {
							result.add(subcontext);
						}
					}
				}
				return result;
			}
		}
		return Collections.emptyList();

	}

	/**
	 * Returns a list of references to all child contexts. If the given context is neither a super context nor a group
	 * context, then it doesn't have any children and an empty list is returned.
	 */
	public List<String> getContextReferences(IContext context) {
		if (isNotGroupOrSuperOrCapabilityContext(context)) {
			return new ArrayList<String>();
		}
		try {
			NamedElement namedElement = context.getNamedElement();
			if (namedElement instanceof GroupContext) {
				return ((GroupContext) namedElement).getContextReferences();
			} else if (namedElement instanceof SuperContext) {
				return ((SuperContext) namedElement).getContextReferences();
			} else if (namedElement instanceof CapabilityContext) {
				final CapabilityContext ccontext = (CapabilityContext) namedElement;
				final Set<String> result = new LinkedHashSet<String>();
				for (CapabilityContextItem item : ccontext.getItems()) {
					result.addAll(item.getContextReferences());
				}
				return new ArrayList<String>(result);
			}

		} catch (ModelException e) {
			RcpttPlugin.log(e);
		}
		return new ArrayList<String>();
	}

	/**
	 * Returns a list of references to all child contexts. If the given context is neither a super context nor a group
	 * context, then it doesn't have any children and an empty list is returned.
	 */
	public List<String> getContextReferences(IContext context, String capability) {
		if (isNotGroupOrSuperOrCapabilityContext(context)) {
			return new ArrayList<String>();
		}
		try {
			NamedElement namedElement = context.getNamedElement();
			if (namedElement instanceof GroupContext) {
				return ((GroupContext) namedElement).getContextReferences();
			} else if (namedElement instanceof SuperContext) {
				return ((SuperContext) namedElement).getContextReferences();
			} else if (namedElement instanceof CapabilityContext) {
				final CapabilityContext ccontext = (CapabilityContext) namedElement;
				for (CapabilityContextItem item : ccontext.getItems()) {
					if (item.getCapability().contains(capability)) {
						return item.getContextReferences();
					}
				}
			}

		} catch (ModelException e) {
			RcpttPlugin.log(e);
		}
		return new ArrayList<String>();
	}

	/**
	 * Returns an array of all verifications in the given scenario, or an empty one in case of an error.
	 */
	public IVerification[] getVerifications(ITestCase scenario, IWorkspaceFinder finder,
			boolean ignoreErrors) {
		try {
			String[] verifications = Q7SearchCore.findVerificationsByDocument(scenario);
			if (verifications == null) {
				verifications = scenario.getVerifications();
			}
			return getVerifications(scenario, Arrays.asList(verifications), finder, ignoreErrors);
		} catch (ModelException e) {
			RcpttPlugin.log(e);
			return new IVerification[0];
		}
	}

	public Map<IQ7NamedElement, IFile> getCopyDestinationMap(
			IQ7NamedElement[] namedElements, IContainer destination) {
		Map<IQ7NamedElement, IFile> result = new TreeMap<IQ7NamedElement, IFile>(
				new Comparator<IQ7NamedElement>() {
					@Override
					public int compare(IQ7NamedElement o1, IQ7NamedElement o2) {
						if (o1.getName() == null) {
							return -1;
						}
						int eo = o1.getName().compareTo(o2.getName());
						if (eo == 0) {
							return o1.equals(o2) ? 0 : -1;
						}
						return eo;
					}
				});

		for (IQ7NamedElement element : namedElements) {
			IFile destinationFile = getDestinationFile(element, destination);
			result.put(element, destinationFile);
		}

		return result;
	}

	public void copy(final IQ7NamedElement[] elements,
			final Map<IQ7NamedElement, IFile> destinations,
			final Map<IQ7NamedElement, String> newNames) throws CoreException {
		ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
			@Override
			public void run(IProgressMonitor monitor) throws CoreException {
				Map<String, String> updatedIds = new HashMap<String, String>();
				List<ITestCase> scenarios = new ArrayList<ITestCase>();
				List<IContext> groups = new ArrayList<IContext>();
				List<ITestSuite> suites = new ArrayList<ITestSuite>();
				for (IQ7NamedElement element : elements) {
					if (element instanceof ITestCase) {
						scenarios.add((ITestCase) element);
					} else if (element instanceof IContext) {
						try {
							IContext context = (IContext) element;
							String oldID = context.getID();
							IContext contextCopy = copyContext(context,
									destinations.get(context), newNames.get(context));
							updatedIds.put(oldID, contextCopy.getID());

							if (contextCopy.getNamedElement() instanceof GroupContext) {
								groups.add(contextCopy);
							}
						} catch (IOException e) {
							RcpttPlugin.log(e);
						} catch (CoreException e) {
							RcpttPlugin.log(e);
						}
					} else if (element instanceof IVerification) {
						try {
							IVerification verification = (IVerification) element;
							String oldID = verification.getID();
							IVerification verificationCopy = copyVerification(verification,
									destinations.get(verification), newNames.get(verification));
							updatedIds.put(oldID, verificationCopy.getID());
						} catch (IOException e) {
							RcpttPlugin.log(e);
						} catch (CoreException e) {
							RcpttPlugin.log(e);
						}
					} else if (element instanceof ITestSuite) {
						try {
							ITestSuite suite = (ITestSuite) element;
							String oldID = suite.getID();
							ITestSuite suiteCopy = copySuite(suite,
									destinations.get(suite), newNames.get(suite));
							updatedIds.put(oldID, suiteCopy.getID());

							suites.add(suiteCopy);
						} catch (IOException e) {
							RcpttPlugin.log(e);
						} catch (CoreException e) {
							RcpttPlugin.log(e);
						}
					}
				}
				for (IContext g : groups) {
					// update context ids
					try {
						IContext copy = (IContext) g.getWorkingCopy(new NullProgressMonitor());
						try {
							EList<String> contextIds = ((GroupContext) copy
									.getNamedElement()).getContextReferences();
							for (int i = 0; i < contextIds.size(); i++) {
								String contextId = contextIds.get(i);
								String newId = updatedIds.get(contextId);
								if (newId != null) {
									contextIds.set(i, newId);
								}
							}
							copy.commitWorkingCopy(true, new NullProgressMonitor());
						} finally {
							copy.discardWorkingCopy();
						}
					} catch (ModelException e) {
						RcpttPlugin.log(e);
					}
				}
				for (ITestSuite s : suites) {
					// update context ids
					try {
						ITestSuite copy = (ITestSuite) s
								.getWorkingCopy(new NullProgressMonitor());
						try {
							EList<TestSuiteItem> contextIds = copy.getTestSuite()
									.getItems();
							for (int i = 0; i < contextIds.size(); i++) {
								TestSuiteItem testSuiteItem = contextIds.get(i);
								String contextId = testSuiteItem.getNamedElementId();
								String newId = updatedIds.get(contextId);
								if (newId != null) {
									testSuiteItem.setNamedElementId(newId);
								}
							}
							copy.commitWorkingCopy(true, new NullProgressMonitor());
						} finally {
							copy.discardWorkingCopy();
						}
					} catch (ModelException e) {
						RcpttPlugin.log(e);
					}
				}

				for (IQ7NamedElement scenario : scenarios) {
					copyScenario((ITestCase) scenario, updatedIds, destinations.get(scenario),
							newNames.get(scenario));
				}
			};
		}, new NullProgressMonitor());
	}

	public IVerification[] getVerifications(IQ7NamedElement element, List<String> verificationIds,
			IWorkspaceFinder finder, boolean ignoreErrors) {
		if (finder == null) {
			finder = WorkspaceFinder.getInstance();
		}
		List<IVerification> verifications = new ArrayList<IVerification>();
		Set<String> projectVerifications = new HashSet<String>();
		// Add project related verifications
		try {
			if (element != null && element instanceof ITestCase) {
				IQ7Project project = element.getQ7Project();
				IQ7ProjectMetadata metadata = project == null ? null : project.getMetadata();
				if (metadata != null && metadata.exists()) {
					String[] defaultVerifications = metadata.getVerifications();
					if (defaultVerifications != null) {
						for (String v : defaultVerifications) {
							IVerification result = findVerification(element, ignoreErrors, v,
									finder);
							if (result != null) {
								verifications.add(result);
								projectVerifications.add(result.getID());
							}
						}
					}
				}
			}
		} catch (ModelException e) {
			RcpttPlugin.log(e);
		}

		for (String vid : verificationIds) {
			if (projectVerifications.contains(vid)) {
				continue;
			}
			IVerification result = findVerification(element, ignoreErrors, vid, finder);
			if (result != null) {
				verifications.add(result);
			}
		}

		return verifications.toArray(new IVerification[verifications.size()]);
	}

	public IContext findContext(IQ7NamedElement element, boolean ignoreErrors,
			String contextId, IWorkspaceFinder finder) {
		IContext[] context = finder.findContext(element, contextId);
		IContext result = null;
		if (context != null && context.length > 0) {
			result = context[0];
		} else {
			RcpttPlugin.log("Failed to get context: " + contextId + " for element:"
					+ element.getName(), null);
			if (!ignoreErrors) {
				UnresolvedContext ctx = ScenarioFactory.eINSTANCE
						.createUnresolvedContext();
				ctx.setName(contextId);
				result = new Q7InternalContext((Q7Folder) element.getParent(), contextId,
						ctx);
			}
		}
		return result;
	}

	private IVerification findVerification(IQ7NamedElement element, boolean ignoreErrors,
			String verificationId, IWorkspaceFinder finder) {
		IVerification[] verification = finder.findVerification(element, verificationId);
		IVerification result = null;
		if (verification != null && verification.length > 0) {
			result = verification[0];
		} else {
			RcpttPlugin.log("Failed to get verification: " + verificationId + " for element:"
					+ element.getName(), null);
			if (!ignoreErrors) {
				UnresolvedVerification unresolved = ScenarioFactory.eINSTANCE
						.createUnresolvedVerification();
				unresolved.setName(verificationId);
				result = new Q7InternalVerification((Q7Folder) element.getParent(), verificationId,
						unresolved);
			}
		}
		return result;
	}

	private void addDefaultContext(List<IContext> contexts) {
		WorkbenchContext defaultWorkbenchContext = ScenarioFactory.eINSTANCE
				.createWorkbenchContext();
		defaultWorkbenchContext.setCloseEditors(false);
		defaultWorkbenchContext.setId(DEFAULT_WORKBENCH_CONTEXT_ID);
		defaultWorkbenchContext.setNoModalDialogs(true);
		defaultWorkbenchContext.setResetPerspective(false);
		defaultWorkbenchContext.setName("Close modal dialogs");
		defaultWorkbenchContext.setDescription("");
		defaultWorkbenchContext.setClearClipboard(false);
		contexts.add(0, new Q7InternalContext(ModelManager.getModelManager().getModel(),
				defaultWorkbenchContext.getName(), defaultWorkbenchContext));
	}

	private IContext copyContext(IContext context, IFile destinationFile, String newName)
			throws IOException, CoreException {
		IContext copy = null;
		try {
			copy = (IContext) copyNamedElement(context, destinationFile);
			if (newName != null) {
				copy.setElementName(newName);
			}

			copy.commitWorkingCopy(true, new NullProgressMonitor());
		} finally {
			if (copy != null) {
				copy.discardWorkingCopy();
			}
		}
		return copy;
	}

	private IVerification copyVerification(IVerification verification, IFile destinationFile, String newName)
			throws IOException, CoreException {
		IVerification copy = null;
		try {
			copy = (IVerification) copyNamedElement(verification, destinationFile);
			if (newName != null) {
				copy.setElementName(newName);
			}

			copy.commitWorkingCopy(true, new NullProgressMonitor());
		} finally {
			if (copy != null) {
				copy.discardWorkingCopy();
			}
		}
		return copy;
	}

	private ITestSuite copySuite(ITestSuite context, IFile destinationFile, String newName)
			throws IOException, CoreException {
		ITestSuite copy = null;
		try {
			copy = (ITestSuite) copyNamedElement(context, destinationFile);
			if (newName != null) {
				copy.setElementName(newName);
			}

			copy.commitWorkingCopy(true, new NullProgressMonitor());
		} finally {
			if (copy != null) {
				copy.discardWorkingCopy();
			}
		}
		return copy;
	}

	private void copyScenario(ITestCase scenario, Map<String, String> updatedIds,
			IFile destinationFile, String newName) throws CoreException {
		ITestCase copy = null;
		try {
			copy = (ITestCase) copyNamedElement(scenario, destinationFile);
			if (newName != null) {
				copy.setElementName(newName);
			}

			List<String> contextIds = new ArrayList<String>(Arrays.asList(copy
					.getContexts()));
			for (int i = 0; i < contextIds.size(); i++) {
				String contextId = contextIds.get(i);
				String newContextId = updatedIds.get(contextId);
				if (newContextId != null) {
					contextIds.set(i, newContextId);
				}
			}
			copy.setContexts(contextIds.toArray(new String[contextIds.size()]));

			List<String> verificationIds = new ArrayList<String>(Arrays.asList(copy
					.getVerifications()));
			for (int i = 0; i < verificationIds.size(); i++) {
				String verificationId = verificationIds.get(i);
				String newVerificationId = updatedIds.get(verificationId);
				if (newVerificationId != null) {
					verificationIds.set(i, newVerificationId);
				}
			}
			copy.setVerifications(
					verificationIds.toArray(new String[verificationIds.size()]));

			copy.commitWorkingCopy(true, new NullProgressMonitor());
		} finally {
			if (copy != null) {
				copy.discardWorkingCopy();
			}
		}
	}

	/**
	 * Return working copy of copied element
	 */
	private IQ7NamedElement copyNamedElement(IQ7NamedElement element,
			IFile destinationFile) throws CoreException, ModelException {

		if (destinationFile != null) {
			if (destinationFile.exists()) {
				destinationFile.delete(true, new NullProgressMonitor());
			}
			element.getResource().copy(destinationFile.getFullPath(), true,
					new NullProgressMonitor());
		} else {
			destinationFile = (IFile) element.getResource();
		}
		IQ7NamedElement copyTestcase = (IQ7NamedElement) RcpttCore.create(destinationFile);
		// update id
		IQ7NamedElement copy = copyTestcase.getWorkingCopy(new NullProgressMonitor());
		IQ7Folder folder = (IQ7Folder) copy.getParent();
		do {
			copy.setID(EcoreUtil.generateUUID());
		} while (folder.haveIDConflict(copy.getID()));
		return copy;
	}

	private IFile getDestinationFile(IQ7NamedElement element,
			IContainer destinationContainer) {
		IFile source = (IFile) element.getResource();
		IPath destinationContainerPath = destinationContainer.getFullPath();

		IWorkspace workspace = source.getWorkspace();
		IPath destinationPath = destinationContainerPath.append(source.getName());
		return workspace.getRoot().getFile(destinationPath);
	}

	private RcpttCore() {
	}

	public static boolean hasRcpttNature(IProject project) {
		try {
			return project.isAccessible() && project.isOpen() && RcpttNature.isRcpttProject(project);
		} catch (CoreException e) {
			RcpttPlugin.log(e);
			return false;
		}
	}

	public static IProject[] getQ7Projects() {
		List<IProject> result = new ArrayList<IProject>();
		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for (IProject iProject : projects) {
			if (hasRcpttNature(iProject)) {
				result.add(iProject);
			}
		}
		return result.toArray(new IProject[result.size()]);
	}

	public IProject[] getNonQ7Projects() {
		List<IProject> result = new ArrayList<IProject>();
		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for (IProject iProject : projects) {
			if (iProject.isAccessible() && iProject.isOpen()) {
				try {
					if (!RcpttNature.isRcpttProject(iProject)) {
						result.add(iProject);
					}
				} catch (CoreException e) {
					RcpttPlugin.log(e);
				}
			}
		}
		return result.toArray(new IProject[result.size()]);
	}

	public void rename(IFile file, IPath newPath) {
		try {
			file.move(newPath, false, new NullProgressMonitor());
		} catch (CoreException e) {
			e.printStackTrace();
		}
	}

	public static boolean isQ7File(IPath path) {
		String ext = path.getFileExtension();
		return IQ7Folder.CONTEXT_FILE_EXTENSION.equals(ext)
				|| IQ7Folder.VERIFICATION_FILE_EXTENSION.equals(ext)
				|| IQ7Folder.SCENARIO_FILE_EXTENSION.equals(ext)
				|| IQ7Folder.TEST_FILE_EXTENSION.equals(ext)
				|| IQ7Folder.TEST_SUITE_FILE_EXTENSION.equals(ext)
				|| isQ7ProjectMetadata(path);
	}

	public static boolean isQ7Context(IPath path) {
		String ext = path.getFileExtension();
		return IQ7Folder.CONTEXT_FILE_EXTENSION.equals(ext);
	}

	public static boolean isQ7Verification(IPath path) {
		String ext = path.getFileExtension();
		return IQ7Folder.VERIFICATION_FILE_EXTENSION.equals(ext);
	}

	public static boolean isQ7TestSuite(IPath path) {
		String ext = path.getFileExtension();
		return IQ7Folder.TEST_SUITE_FILE_EXTENSION.equals(ext);
	}

	public static boolean isQ7ProjectMetadata(IPath path) {
		if (Q7Features.supportQ7OptionsFile) {
			return (path.segmentCount() == 2 && path.lastSegment().equals(
					IQ7Project.METADATA_NAME));
		}
		return false;
	}

	private static String runtimeVersion = null;

	public synchronized static String getRuntimeVersion() {
		if (runtimeVersion != null) {
			return runtimeVersion;
		}

		// runtimeVersion = "";
		String runtimeBundleId = "org.eclipse.rcptt.updates.runtime.e4x";
		Bundle runtimeBundle = Platform.getBundle(runtimeBundleId);
		if (runtimeBundle == null)
			throw new NullPointerException(runtimeBundleId
					+ " plugin is not loaded");
		Enumeration<String> paths = runtimeBundle.getEntryPaths("q7/plugins/");
		if (paths == null)
			return null;

		while (paths.hasMoreElements()) {
			String path = paths.nextElement();
			String st = "org.eclipse.rcptt.tesla.swt_";
			int ind = path.indexOf(st);
			if (ind > 0) {
				String version = path.substring(ind + st.length()).trim();
				if (version.endsWith(".jar")) {
					version = version.substring(0, version.length() - 4);
					String shot = "-SNAPSHOT";
					if (version.endsWith(shot)) {
						version = version.substring(0, version.length() - shot.length());
					}
					runtimeVersion = version;
					break;
				}
			}
		}

		return runtimeVersion;
	}

	public static IQ7Project create(IProject project) {
		if (project == null) {
			return null;
		}
		Q7Model model = ModelManager.getModelManager().getModel();
		return model.getProject(project);
	}

	public static IQ7Element create(IResource resource) {
		return ModelManager.create(resource, null);
	}

	public static IQ7Model create(IWorkspaceRoot root) {
		if (root == null) {
			return null;
		}
		return ModelManager.getModelManager().getModel();
	}

	// Listeners
	private static void addElementChangedListener(IElementChangedListener listener,
			int eventMask) {
		ModelManager.getModelManager().deltaState.addElementChangedListener(listener,
				eventMask);
	}

	public static void addElementChangedListener(IElementChangedListener listener) {
		addElementChangedListener(listener, Q7ElementChangedEvent.POST_CHANGE
				| Q7ElementChangedEvent.POST_RECONCILE);
	}

	public static void removeElementChangedListener(IElementChangedListener listener) {
		ModelManager.getModelManager().deltaState.removeElementChangedListener(listener);
	}

	public void findAllContexts(IQ7NamedElement element, Set<? super IContext> ctx) {
		for (IContext cx : getContexts(element, WorkspaceFinder.getInstance(), true)) {
			if (!(cx instanceof Q7InternalContext)) {
				if (ctx.add(cx)) {
					findAllContexts(cx, ctx);
				}
			}
		}
	}

	public void findAllVerifications(IQ7NamedElement element, Set<? super IVerification> verifications) {
		if (element instanceof ITestCase) {
			IVerification[] result = getVerifications((ITestCase) element, WorkspaceFinder.getInstance(), true);
			verifications.addAll(Arrays.asList(result));
		}
	}

	public boolean isNotGroupOrSuperOrCapabilityContext(IContext context) {
		String type = Q7SearchCore.findContextTypeByDocument(context);
		if (type == null && context != null) {
			try {
				type = context.getType().getId();
			} catch (ModelException e) {
				RcpttPlugin.log(e);
			}
		}
		if (type == null) {
			return false;
		}
		if (!"org.eclipse.rcptt.ctx.capability".equals(type) && !"org.eclipse.rcptt.ctx.group".equals(type)
				&& !"org.eclipse.rcptt.ctx.super".equals(type)) {
			return true;
		}
		return false;
	}

	public static String getResourcePath(String id) {
		if (id == null) {
			return null;
		}
		IQ7NamedElement element = Q7SearchCore.findById(id);
		if (element == null) {
			return null;
		}
		return element.getResource().getFullPath().toString();
	}
}