import java.text.DateFormat;

import java.util.Date;

import java.util.Map;

import org.eclipse.cdt.core.model.CoreModel;

import org.eclipse.cdt.core.settings.model.CProjectDescriptionEvent;

import org.eclipse.cdt.core.settings.model.ICProjectDescription;

import org.eclipse.cdt.core.settings.model.ICProjectDescriptionListener;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IResourceChangeEvent;

import org.eclipse.core.resources.IResourceChangeListener;

import org.eclipse.core.resources.IResourceDelta;

import org.eclipse.core.resources.IResourceDeltaVisitor;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExtension;

import org.eclipse.core.runtime.IExtensionPoint;

import org.eclipse.core.runtime.IExtensionRegistry;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.SubMonitor;

import org.eclipse.osgi.service.debug.DebugOptions;

import org.osgi.framework.BundleContext;

import org.osgi.framework.ServiceReference;

public class ExecutablesManager extends PlatformObject implements IResourceChangeListener, ICProjectDescriptionListener {

	private static final String EXECUTABLES_MANAGER_DEBUG_TRACING = CDebugCorePlugin.PLUGIN_ID + "EXECUTABLES_MANAGER_DEBUG_TRACING"; //$NON-NLS-1$

	private Map<IProject, IProjectExecutablesProvider> executablesProviderMap = new HashMap<IProject, IProjectExecutablesProvider>();

	private Map<IProject, List<Executable>> executablesMap = new HashMap<IProject, List<Executable>>();

	private List<IExecutablesChangeListener> changeListeners = Collections.synchronizedList(new ArrayList<IExecutablesChangeListener>());

	private List<IProjectExecutablesProvider> executableProviders;

	private List<ISourceFilesProvider> sourceFileProviders;

	private List<ISourceFileRemapping> sourceFileRemappings;

	private List<IExecutableImporter> executableImporters;

	private boolean DEBUG;

			trace("Get Executables job started at "

					+ getStringFromTimestamp(System.currentTimeMillis()));

			List<IProject> projects = getProjectsToCheck();

			SubMonitor subMonitor = SubMonitor

					.convert(monitor, projects.size());

			for (IProject project : projects) {

				if (subMonitor.isCanceled()) {

					trace("Get Executables job cancelled at "

							+ getStringFromTimestamp(System.currentTimeMillis()));

					return Status.CANCEL_STATUS;

				}

				subMonitor.subTask("Checking project: " + project.getName());

				// get the executables provider for this project

				IProjectExecutablesProvider provider = getExecutablesProviderForProject(project);

				if (provider != null) {

					trace("Getting executables for project: "

							+ project.getName() + " using "

							+ provider.toString());

					// store the list of executables for this project

					synchronized (executablesMap) {

						executablesMap.put(project, provider.getExecutables(

								project, subMonitor.newChild(1,

										SubMonitor.SUPPRESS_NONE)));

					}

				}

			}

			// notify the listeners

			synchronized (changeListeners) {

				for (IExecutablesChangeListener listener : changeListeners) {

					listener.executablesListChanged();

				}

			}

			trace("Get Executables job finished at "

					+ getStringFromTimestamp(System.currentTimeMillis()));

	/**

	* Get the executables manager instance

	* @return the executables manager

	*/

		// check if debugging is enabled

		BundleContext context = CDebugCorePlugin.getDefault().getBundle()

				.getBundleContext();

		if (context != null) {

			ServiceReference reference = CDebugCorePlugin.getDefault()

					.getBundle().getBundleContext().getServiceReference(

							DebugOptions.class.getName());

			if (reference != null) {

				DebugOptions service = (DebugOptions) context

						.getService(reference);

				if (service != null) {

					try {

						DEBUG = service.getBooleanOption(

								EXECUTABLES_MANAGER_DEBUG_TRACING, false);

					} finally {

						// we have what we want - release the service

						context.ungetService(reference);

					}

				}

			}

		}

		refreshJob.setPriority(Job.SHORT);

		// load the extension points

		loadExecutableProviderExtensions();

		loadSoureFileProviderExtensions();

		loadSoureRemappingExtensions();

		loadExecutableImporterExtensions();

		// add the standard providers

		executableProviders.add(0, new StandardExecutableProvider());

		sourceFileProviders.add(0, new StandardSourceFilesProvider());

		sourceFileRemappings.add(0, new StandardSourceFileRemapping());

		executableImporters.add(0, new StandardExecutableImporter());

		// listen for events we're interested in

		ResourcesPlugin.getWorkspace().addResourceChangeListener(

				this,

				IResourceChangeEvent.POST_CHANGE

						| IResourceChangeEvent.POST_BUILD);

		CoreModel.getDefault().getProjectDescriptionManager()

				.addCProjectDescriptionListener(this,

						CProjectDescriptionEvent.DATA_APPLIED);

		// schedule a refresh so we get up to date

		scheduleRefresh();

	/**

	* Adds an executable listener

	* @param listener the listener to add

	*/

	/**

	* Removes an executable listener

	* @param listener the listener to remove

	*/

	* Gets the list of executables in the workspace.

	* @return the list of executables which may be empty

	*/

	public Collection<Executable> getExecutables() {	

		trace("getExecutables called at " + getStringFromTimestamp(System.currentTimeMillis()));

		List<Executable> executables = new ArrayList<Executable>();

		synchronized (executablesMap) {

			for (List<Executable> exes : executablesMap.values()) {

				for (Executable exe : exes) {

					if (!executables.contains(exe)) {

						executables.add(exe);

					}

		trace("getExecutables returned at " + getStringFromTimestamp(System.currentTimeMillis()));

		return executables;

	* Gets the collection of executables for the given project

	* @param project the project

	* @return collection of executables which may be empty

	*/

	public Collection<Executable> getExecutablesForProject(IProject project) {

		List<Executable> executables = new ArrayList<Executable>();

		synchronized (executablesMap) {

			List<Executable> exes = executablesMap.get(project);

			if (exes != null) {

				for (Executable exe : exes) {

					if (!executables.contains(exe)) {

						executables.add(exe);

					}

				}

			}

		}

		return executables;

	}

	/**

	* Attempt to remap the path to the given source file in the given executable using

	* source file mapping extensions

	* @param executable the executable

	* @param filePath the absolute path to the source file

	* @return the new path to the source file, which was remapped if possible

	*

	* @since 6.0

	*/

	/**

	* Import the given executables into the manager

	* @param fileNames the absolute paths of the executables to import

	* @param monitor progress monitor

	*/

	public void importExecutables(final String[] fileNames,

			IProgressMonitor monitor) {

		monitor.beginTask("Import Executables", executableImporters.size());

		synchronized (executableImporters) {

			Collections.sort(executableImporters,

					new Comparator<IExecutableImporter>() {

						public int compare(IExecutableImporter arg0,

								IExecutableImporter arg1) {

							int p0 = arg0.getPriority(fileNames);

							int p1 = arg1.getPriority(fileNames);

							if (p0 < p1)

								return 1;

							if (p0 > p1)

								return -1;

							return 0;

						}

					});

			for (IExecutableImporter importer : executableImporters) {

				if (handled || monitor.isCanceled()) {

					break;

				}

			}

		}

		scheduleRefresh();

	}

	/**

	 * Determines if the given executable is currently known by the manager

	 * 

	 * @param exePath

	 *            the absolute path to the executable

	 * @return true if the manager knows about it, false otherwise

	 */

	public boolean executableExists(IPath exePath) {

		synchronized (executablesMap) {

			for (List<Executable> exes : executablesMap.values()) {

				for (Executable exe : exes) {

					if (exe.getPath().equals(exePath)) {

						return true;

		return false;

	/**

	* Get the list of source files for the given executable

	* @param executable the executable

	* @param monitor progress monitor

	* @return an array of source files which may be empty

	*/

	public String[] getSourceFiles(final Executable executable, IProgressMonitor monitor) {

			String[] result = new String[0];

			trace("getSourceFiles called at " + getStringFromTimestamp(System.currentTimeMillis()) + " for " + executable.getPath().toOSString());

				if (sourceFiles.length > 0) {

					trace("getSourceFiles got " + sourceFiles.length + " files from " + provider.toString());

			trace("getSourceFiles returned at " + getStringFromTimestamp(System.currentTimeMillis()));

	* Removes the given executables

	* @param executables the array of executables to be removed

	* @param monitor progress monitor

	* @return IStatus of the operation

	* 

	* @since 6.0

	*/

	public IStatus removeExecutables(Executable[] executables,

			IProgressMonitor monitor) {

		MultiStatus status = new MultiStatus(CDebugCorePlugin.PLUGIN_ID,

				IStatus.WARNING,

				"Couldn't remove all of the selected executables", null);

		monitor.beginTask("Remove Executables", executables.length);

			IProjectExecutablesProvider provider = getExecutablesProviderForProject(executable

					.getProject());

			if (provider != null) {

				IStatus result = provider.removeExecutable(executable,

						new SubProgressMonitor(monitor, 1));

				if (result.isOK()) {

					// remove the exe from the list

					List<Executable> exes = executablesMap.get(executable

							.getProject());

					if (exes != null) {

						exes.remove(executable);

					}

				} else {

					status.add(result);

				}

		// notify listeners that the list has changed. only do this if at least

		// one delete succeeded.

		if (status.getChildren().length != executables.length) {

			synchronized (changeListeners) {

				for (IExecutablesChangeListener listener : changeListeners) {

					listener.executablesListChanged();

				}

			}

		}

		return status;

	* Refresh the list of executables for the given projects

	* @param projects the list of projects, or null.  if null or the list

	* is empty, all projects will be refreshed.

	*/

	public void refresh(List<IProject> projects) {

		if (projects == null || projects.size() == 0) {

			// clear the entire cache

			executablesMap.clear();

		} else {

			for (IProject project : projects) {

				executablesMap.remove(project);

			}

		}

		scheduleRefresh();

	}

	public void resourceChanged(IResourceChangeEvent event) {

		synchronized (executablesMap) {

			// project needs to be refreshed after a build/clean as the binary

			// may

			// be added/removed/renamed etc.

			if (event.getType() == IResourceChangeEvent.POST_BUILD) {

				Object obj = event.getSource();

				if (obj != null && obj instanceof IProject) {

					if (executablesMap.containsKey(obj)) {

						List<Executable> executables = executablesMap

								.remove(obj);

						trace("Scheduling refresh because project "

								+ ((IProject) obj).getName()

								+ " built or cleaned");

						scheduleRefresh();

						// notify the listeners that these executables have

						// possibly changed

						if (executables != null && executables.size() > 0) {

							synchronized (changeListeners) {

								for (IExecutablesChangeListener listener : changeListeners) {

									listener.executablesChanged(executables);

								}

							}

						}

					}

				}

				return;

			}

			// refresh when projects are opened or closed. note that deleted

			// projects are handled later in this method. new projects are

			// handled

			// in handleEvent. resource changed events always start at the

			// workspace

			// root, so projects are the next level down

			boolean refreshNeeded = false;

			IResourceDelta[] projects = event.getDelta().getAffectedChildren();

			for (IResourceDelta projectDelta : projects) {