import java.util.Arrays;

import org.eclipse.cdt.debug.internal.core.executables.ExecutablesChangeEvent;

import org.eclipse.cdt.debug.internal.core.executables.StandardExecutableProvider;

import org.eclipse.debug.core.DebugPlugin;

public class ExecutablesManager extends PlatformObject {

	private final HashMap<String, Executable> executables = new HashMap<String, Executable>();

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

	private final List<ISourceFileRemapping> sourceFileRemappings = Collections.synchronizedList(new ArrayList<ISourceFileRemapping>());

	private final List<IExecutableProvider> executableProviders = Collections.synchronizedList(new ArrayList<IExecutableProvider>());

	private final List<ISourceFilesProvider> sourceFileProviders = Collections.synchronizedList(new ArrayList<ISourceFilesProvider>());

	private final List<IExecutableImporter> executableImporters = Collections.synchronizedList(new ArrayList<IExecutableImporter>());

	private boolean refreshNeeded = true;

	private boolean tempDisableRefresh = false;

			refreshExecutables(monitor);

		addSourceFileRemapping(new StandardSourceFileRemapping());

		addExecutableImporter(new StandardExecutableImporter());

		addExecutablesProvider(new StandardExecutableProvider());

		addSourceFilesProvider(new StandardSourceFilesProvider());

	public void addSourceFileRemapping(ISourceFileRemapping remapping) {

		sourceFileRemappings.add(remapping);

	}

	public void removeSourceFileRemapping(ISourceFileRemapping remapping) {

		sourceFileRemappings.remove(remapping);

	}

	public void addExecutableImporter(IExecutableImporter importer) {

		executableImporters.add(importer);

	}

	public void removeExecutableImporter(IExecutableImporter importer) {

		executableImporters.remove(importer);

	}

	public void addExecutablesProvider(IExecutableProvider provider) {

		executableProviders.add(provider);

	}

	/**

	 * @since 6.0

	 */

	public void addSourceFilesProvider(ISourceFilesProvider provider) {

		sourceFileProviders.add(provider);

	}

	 * @since 6.0

	 */

	public void removeSourceFilesProvider(ISourceFilesProvider provider) {

		sourceFileProviders.remove(provider);

	}

	public void removeExecutablesProvider(IExecutableProvider provider) {

		executableProviders.remove(provider);

	}

	public IStatus refreshExecutables(IProgressMonitor monitor) {

		if (tempDisableRefresh) {

			return Status.OK_STATUS;

		}

		synchronized (executables) {

			HashMap<String, Executable> oldList = new HashMap<String, Executable>(executables);

			executables.clear();

			IExecutableProvider[] exeProviders = getExecutableProviders();

			Arrays.sort(exeProviders, new Comparator<IExecutableProvider>() {

				public int compare(IExecutableProvider arg0, IExecutableProvider arg1) {

					int p0 = arg0.getPriority();

					int p1 = arg1.getPriority();

					if (p0 > p1)

						return 1;

					if (p0 < p1)

						return -1;

					return 0;

				}});

			refreshNeeded = false;

			monitor.beginTask("Refresh Executables", exeProviders.length);

			for (IExecutableProvider provider : exeProviders) {

				Executable[] exes = provider.getExecutables(new SubProgressMonitor(monitor, 1));

				for (Executable executable : exes) {

					executables.put(executable.getPath().toOSString(), executable);

				}

			}

			monitor.done();

			synchronized (changeListeners) {

				Collection<Executable> newExes = executables.values();

				Executable[] exeArray = newExes.toArray(new Executable[newExes.size()]);

				Collection<Executable> oldExes = oldList.values();

				Executable[] oldArray = oldExes.toArray(new Executable[oldExes.size()]);				

				for (IExecutablesChangeListener listener : changeListeners) {

					listener.executablesChanged(new ExecutablesChangeEvent(oldArray, exeArray));

		return monitor.isCanceled() ? Status.CANCEL_STATUS : Status.OK_STATUS;

	}

	public Executable[] getExecutables() {

		if (refreshNeeded) {

			try {

				refreshJob.schedule();

				refreshJob.join();

			} catch (InterruptedException e) {

				DebugPlugin.log( e );

			}

		}

		synchronized (executables)

		{

			Collection<Executable> exes = executables.values();

			return exes.toArray(new Executable[exes.size()]);

		}

	 * @since 6.0

	 */

	public void importExecutables(final String[] fileNames, IProgressMonitor monitor) {

		try {

			tempDisableRefresh = true;

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

					handled = importer.importExecutables(fileNames, new SubProgressMonitor(monitor, 1));

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

						break;

		} finally {

			tempDisableRefresh = false;

		if (handled)

			refreshExecutables(monitor);

		monitor.done();

	public ISourceFileRemapping[] getSourceFileRemappings() {

		return sourceFileRemappings.toArray(new ISourceFileRemapping[sourceFileRemappings.size()]);

	}

	public IExecutableImporter[] getExecutableImporters() {

		return executableImporters.toArray(new IExecutableImporter[executableImporters.size()]);

	}

	public void scheduleRefresh(IExecutableProvider provider, long delay) {

		refreshNeeded = true;

		refreshJob.schedule(delay);

	}

	public boolean refreshNeeded() {

		return refreshNeeded;

	}

	public boolean executableExists(IPath exePath) {

		synchronized (executables) {

			return executables.containsKey(exePath.toOSString());			

		}

	}

	 * @since 6.0

	 */

	public String[] getSourceFiles(final Executable executable,

			IProgressMonitor monitor) {

		String[] result = new String[0];

				if (sourceFiles.length > 0)

				{

	 * @since 6.0

	 */

	public IStatus removeExecutables(Executable[] executables, IProgressMonitor monitor) {

		IExecutableProvider[] exeProviders = getExecutableProviders();

		IStatus result = Status.OK_STATUS;

		Arrays.sort(exeProviders, new Comparator<IExecutableProvider>() {

			public int compare(IExecutableProvider arg0, IExecutableProvider arg1) {

				int p0 = arg0.getPriority();

				int p1 = arg1.getPriority();

				if (p0 > p1)

					return 1;

				if (p0 < p1)

					return -1;

				return 0;

			}

		});

		MultiStatus combinedStatus = new MultiStatus(CDebugCorePlugin.PLUGIN_ID, IStatus.WARNING, "Couldn't remove all of the selected executables", null);

		refreshNeeded = false;

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

			boolean handled = false;

			IStatus rmvStatus = Status.OK_STATUS;;

			for (IExecutableProvider provider : exeProviders) {

				if (!handled)

				{

					rmvStatus = provider.removeExecutable(executable, new SubProgressMonitor(monitor, 1));

					handled = rmvStatus.getSeverity() == IStatus.OK;

				}				

			}

			if (!handled)

			{

				combinedStatus.add(rmvStatus);

				result = combinedStatus;

		monitor.done();

		return result;

	 * @since 6.0

	 */

	public void setRefreshNeeded(boolean refresh) {

		refreshNeeded = true;

}