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;

	* @since 6.0

	* 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  

	 */ 

		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);

		for (Executable executable : executables) {

			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) {

				if ((projectDelta.getFlags() & IResourceDelta.OPEN) != 0) {

					if (projectDelta.getKind() == IResourceDelta.CHANGED) {

						// project was opened or closed

						if (executablesMap.containsKey(projectDelta

								.getResource())) {

							executablesMap.remove(projectDelta.getResource());

						}

						refreshNeeded = true;

					}

				}

			}

			if (refreshNeeded) {

				trace("Scheduling refresh because project(s) opened or closed");

				scheduleRefresh();

				return;

			}

			try {

				event.getDelta().accept(new IResourceDeltaVisitor() {

					public boolean visit(IResourceDelta delta)

							throws CoreException {

						if (delta.getKind() == IResourceDelta.ADDED

								|| delta.getKind() == IResourceDelta.REMOVED) {

							IResource deltaResource = delta.getResource();

							if (deltaResource != null) {

								boolean refresh = false;

								if (delta.getKind() == IResourceDelta.REMOVED

										&& deltaResource instanceof IProject) {

									// project deleted

									if (executablesMap

											.containsKey(deltaResource)) {

										executablesMap.remove(deltaResource);