import java.util.Map;

import java.util.Properties;

import org.eclipse.cdt.debug.core.CDebugUtils;

import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;

import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;

import org.eclipse.cdt.dsf.concurrent.ReflectionSequence;

import org.eclipse.cdt.dsf.concurrent.Sequence;

import org.eclipse.cdt.dsf.debug.service.IBreakpoints.IBreakpointsTargetDMContext;

import org.eclipse.cdt.dsf.debug.service.command.ICommand;

import org.eclipse.cdt.dsf.gdb.IGDBLaunchConfigurationConstants;

import org.eclipse.cdt.dsf.mi.service.command.output.MIBreakInsertInfo;

import org.eclipse.cdt.dsf.mi.service.command.output.MIBreakpoint;

import org.eclipse.core.runtime.CoreException;

    private IGDBBackend fBackend;

    	fBackend = getServicesTracker().getService(IGDBBackend.class);

	@Override

	protected boolean doIsDebuggerAttachSupported() {

		return true;

	}

	@Override

	protected boolean doCanDetachDebuggerFromProcess() {

		return true;

	}

	protected class DebugNewProcessSequence extends ReflectionSequence {

		private String fBinaryName;

		private Map<String, Object> fAttributes;

		private IMIContainerDMContext fContainerCtx;

		// Store the dataRM so that we can fill it with the container context that we will be creating

		private DataRequestMonitor<IDMContext> fDataRequestMonitor;

		public DebugNewProcessSequence(IDMContext dmc, String file, Map<String, Object> attributes, final DataRequestMonitor<IDMContext> rm) {

			super(GDBProcesses_7_2.this.getExecutor(), rm);

			fBinaryName = file;

			fAttributes = attributes;

			fDataRequestMonitor = rm;

		}

		@Override

		protected String[] getExecutionOrder(String group) {

			if (GROUP_TOP_LEVEL.equals(group)) {

				return new String[] {

						"stepAddInferior",  //$NON-NLS-1$

						"stepSetEnvironmentVariables",   //$NON-NLS-1$

						"stepSetExecutable",   //$NON-NLS-1$

						"stepSetArguments",   //$NON-NLS-1$

						"stepStartExecution",   //$NON-NLS-1$

				};

			}

			return null;

		}

		/**

		 * Start executing the program.

		 */

		@Execute

		public void stepAddInferior(final RequestMonitor rm) {

	        fCommandControl.queueCommand(

	        		fCommandFactory.createMIAddInferior(fCommandControl.getContext()),

	        		new DataRequestMonitor<MIAddInferiorInfo>(ImmediateExecutor.getInstance(), rm) {

	        			@Override

	        			protected void handleSuccess() {

	        				final String groupId = getData().getGroupId();

	        				if (groupId == null || groupId.trim().length() == 0) {

	 				           rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid gdb group id.", null)); //$NON-NLS-1$

					           rm.done();

					           return;

	    					}

	        				IProcessDMContext procCtx = createProcessContext(fCommandControl.getContext(), null);

	        				fContainerCtx = createContainerContext(procCtx, groupId);

	        				rm.done();

	        			}

	        		});

		}

		/**

		 * Specify environment variables if needed

		 */

		@Execute

		public void stepSetEnvironmentVariables(RequestMonitor rm) {

			boolean clear = false;

			Properties properties = new Properties();

			try {

				// here we need to pass the proper container context

				clear = fBackend.getClearEnvironment();

				properties = fBackend.getEnvironmentVariables();

			} catch (CoreException e) {

				rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, -1, "Cannot get environment information", e)); //$NON-NLS-1$

				rm.done();

				return;

			}

			if (clear == true || properties.size() > 0) {

				// here we need to pass the proper container context

				fCommandControl.setEnvironment(properties, clear, rm);

			} else {

				rm.done();

			}

		}

		/**

		 * Specify the executable file to be debugged and read the symbol table.

		 */

		@Execute

		public void stepSetExecutable(RequestMonitor rm) {

			boolean noFileCommand = CDebugUtils.getAttribute(fAttributes, IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_USE_SOLIB_SYMBOLS_FOR_APP,

											             	              IGDBLaunchConfigurationConstants.DEBUGGER_USE_SOLIB_SYMBOLS_FOR_APP_DEFAULT);

			if (!noFileCommand && fBinaryName != null && fBinaryName.length() > 0) {

				fCommandControl.queueCommand(

						fCommandFactory.createMIFileExecAndSymbols(fContainerCtx, fBinaryName), 

						new DataRequestMonitor<MIInfo>(getExecutor(), rm));

			} else {

				rm.done();

			}

		}

		/**

		 * Specify the arguments to the executable file.

		 */

		@Execute

		public void stepSetArguments(RequestMonitor rm) {

			try {

				String args = fBackend.getProgramArguments();

				if (args != null) {

					fCommandControl.queueCommand(

							// here we need to pass the proper container context

							fCommandFactory.createMIGDBSetArgs(fCommandControl.getContext(), args), 

							new DataRequestMonitor<MIInfo>(getExecutor(), rm));

				} else {

					rm.done();

				}

			} catch (CoreException e) {

				rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, -1, "Cannot get inferior arguments", e)); //$NON-NLS-1$

				rm.done();

			}    		

		}

		/**

		 * Start executing the program.

		 */

		@Execute

		public void stepStartExecution(final RequestMonitor rm) {

			startOrRestart(fContainerCtx, fAttributes, false, new DataRequestMonitor<IMIContainerDMContext>(ImmediateExecutor.getInstance(), rm) {

				@Override

				protected void handleSuccess() {

					// Set the container that we created

					fDataRequestMonitor.setData(getData());

					// Don't call fDataRequestMonitor.done(), the sequence will

					// automatically do that when we call rm.done();

					rm.done();

				}

			});

		}

	}

	@Override

	public void debugNewProcess(IDMContext dmc, String file, 

			                    Map<String, Object> attributes, DataRequestMonitor<IDMContext> rm) {

		Sequence debugNewProcess = new DebugNewProcessSequence(dmc, file, attributes, rm);

   		ImmediateExecutor.getInstance().execute(debugNewProcess);

	}

	protected class StartOrRestartProcessSequence extends ReflectionSequence {

		// This variable will be used to store the original container context,

		// but once the new process is start (restarted), it will contain the new

		// container context.  This new container context has for parent the process

		// context, which holds the new pid.

		private IMIContainerDMContext fContainerDmc;

    	private MIBreakpoint fUserBreakpoint = null;

    	private boolean fUserBreakpointIsOnMain = false;

    	private boolean fReverseEnabled;

    	private boolean fRestart;

    	private Map<String, Object> fAttributes;

		// Store the dataRM so that we can fill it with the container context that we will be creating

		private DataRequestMonitor<IMIContainerDMContext> fDataRequestMonitor;

		public StartOrRestartProcessSequence(IMIContainerDMContext containerDmc, Map<String, Object> attributes, 

											 boolean restart, DataRequestMonitor<IMIContainerDMContext> rm) {

			super(GDBProcesses_7_2.this.getExecutor(), rm);

			fContainerDmc = containerDmc;

			fAttributes = attributes;

			fRestart = restart;

			fDataRequestMonitor = rm;

			fReverseEnabled = CDebugUtils.getAttribute(attributes, IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_REVERSE,

													   IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_DEFAULT);

		}

		@Override

		protected String[] getExecutionOrder(String group) {

			if (GROUP_TOP_LEVEL.equals(group)) {

				return new String[] {

						"stepInsertStopOnMainBreakpoint",  //$NON-NLS-1$

						"stepSetBreakpointForReverse",   //$NON-NLS-1$

						"stepRunProgram",   //$NON-NLS-1$

						"stepSetReverseOff",   //$NON-NLS-1$

						"stepEnableReverse",   //$NON-NLS-1$

						"stepContinue",   //$NON-NLS-1$

				};

			}

			return null;

		}

		/**

		 * If the user requested a 'stopOnMain', let's set the temporary breakpoint

		 * where the user specified.

		 */

		@Execute

		public void stepInsertStopOnMainBreakpoint(final RequestMonitor rm) {

			boolean userRequestedStop = CDebugUtils.getAttribute(fAttributes, 

					ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_STOP_AT_MAIN,

					false);

			if (userRequestedStop) {

				String userStopSymbol = CDebugUtils.getAttribute(fAttributes, 

						ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_STOP_AT_MAIN_SYMBOL,

						ICDTLaunchConfigurationConstants.DEBUGGER_STOP_AT_MAIN_SYMBOL_DEFAULT);

				fCommandControl.queueCommand(

						fCommandFactory.createMIBreakInsert((IBreakpointsTargetDMContext)fCommandControl.getContext(),

								true, false, null, 0, userStopSymbol, 0),

								new DataRequestMonitor<MIBreakInsertInfo>(getExecutor(), rm) {

							@Override

							public void handleSuccess() {

								if (getData() != null) {

									MIBreakpoint[] breakpoints = getData().getMIBreakpoints();

									if (breakpoints.length > 0) {

										fUserBreakpoint = breakpoints[0];

									}

								}

								rm.done();

							}

						});

			} else {

				rm.done();

			}

		}

		/*

		 * If reverse debugging, set a breakpoint on main to be able to enable reverse

		 * as early as possible.

		 * If the user has requested a stop at the same point, we could skip this breakpoint

		 * however, we have to first set it to find out!  So, we just leave it.

		 */

		@Execute

		public void stepSetBreakpointForReverse(final RequestMonitor rm) {

			if (fReverseEnabled) {

				fCommandControl.queueCommand(

						fCommandFactory.createMIBreakInsert((IBreakpointsTargetDMContext)fCommandControl.getContext(),

								true, false, null, 0, ICDTLaunchConfigurationConstants.DEBUGGER_STOP_AT_MAIN_SYMBOL_DEFAULT, 0),

								new DataRequestMonitor<MIBreakInsertInfo>(getExecutor(), rm) {

							@Override

							public void handleSuccess() {

								if (getData() != null) {

									MIBreakpoint[] breakpoints = getData().getMIBreakpoints();

									if (breakpoints.length > 0 && fUserBreakpoint != null) {

										fUserBreakpointIsOnMain = breakpoints[0].getAddress().equals(fUserBreakpoint.getAddress());

									}

								}

								rm.done();

							}

						});

			} else {

				rm.done();

			}

		}

		/*

		 * Now, run the program.  Use either -exec-run or -exec-continue depending

		 * on whether we have remote session or not.

		 */

		@Execute

		public void stepRunProgram(final RequestMonitor rm) {

			ICommand<MIInfo> command;

			if (useContinueCommand(fAttributes, fRestart)) {

				command = fCommandFactory.createMIExecContinue(fContainerDmc);

			} else {

				command = fCommandFactory.createMIExecRun(fContainerDmc);	

			}

			fCommandControl.queueCommand(command, new DataRequestMonitor<MIInfo>(ImmediateExecutor.getInstance(), rm) {

				@Override

				protected void handleSuccess() {

					// Now that the process is started, the pid has been allocated

					// so we need to fetch the proper container context

					// We replace our current context which does not have the pid, with one that has the pid.

					fContainerDmc = createContainerContextFromGroupId(fCommandControl.getContext(), fContainerDmc.getGroupId());

					fDataRequestMonitor.setData(fContainerDmc);

					rm.done();

				}

			});

		}

		/*

		 * In case of a restart, reverse debugging should be marked as off here because

		 * GDB will have turned it off. We may turn it back on after.

		 */

		@Execute

		public void stepSetReverseOff(RequestMonitor rm) {

			// Although it only makes sense for a restart, it doesn't hurt

			// do to it all the time.

			GDBRunControl_7_0 reverseService = getServicesTracker().getService(GDBRunControl_7_0.class);

			if (reverseService != null) {

				reverseService.setReverseModeEnabled(false);

			}

			rm.done();

		}

		/*

		 * Since we have started the program, we can turn on reverse debugging if needed

		 */

		@Execute

		public void stepEnableReverse(RequestMonitor rm) {

			if (fReverseEnabled) {

				IReverseRunControl reverseService = getServicesTracker().getService(IReverseRunControl.class);

				if (reverseService != null) {

					reverseService.enableReverseMode(fCommandControl.getContext(), true, rm);

					return;

				}

			}

			rm.done();

		}

		/*

		 * Finally, if we are enabling reverse, and the userSymbolStop is not on main,

		 * we should do a continue because we are currently stopped on main but that 

		 * is not what the user requested

		 */

		@Execute

		public void stepContinue(RequestMonitor rm) {

			if (fReverseEnabled && !fUserBreakpointIsOnMain) {

				fCommandControl.queueCommand(fCommandFactory.createMIExecContinue(fContainerDmc),

						new DataRequestMonitor<MIInfo>(getExecutor(), rm));

			} else {

				rm.done();

			}

		}

	};

	/**

     * Insert breakpoint at entry if set, and start or restart the program.

     * Note that restart does not apply to remote or attach sessions.

     * 

     * If we want to enable Reverse debugging from the start of the program we do the following:

     * attachSession => enable reverse

     * else => set temp bp on main, run, enable reverse, continue if bp on main was not requested by user 

     */

    protected void startOrRestart(IMIContainerDMContext containerDmc, Map<String, Object> attributes, boolean restart, DataRequestMonitor<IMIContainerDMContext> rm) {

		final boolean reverseEnabled = CDebugUtils.getAttribute(attributes, IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_REVERSE,

       																        IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_DEFAULT);

   		if (fBackend.getIsAttachSession()) {

   			// Restart does not apply to attach sessions.

   			//

   			// When attaching to a running process, we do not need to set a breakpoint or

   			// start the program; it is left up to the user.

   			// We only need to turn on Reverse Debugging if requested.

   			if (reverseEnabled) {

   				IReverseRunControl reverseService = getServicesTracker().getService(IReverseRunControl.class);

   				if (reverseService != null) {

   					reverseService.enableReverseMode(fCommandControl.getContext(), true, rm);

   					return;

   				}

   			}

   			//TODO khouzam must set rm.setdata()

   			rm.done();

   			return;

   		}

   		// When it is not an attach session, it gets a little more complicated

   		// so let's use a sequence.

   		ImmediateExecutor.getInstance().execute(new StartOrRestartProcessSequence(containerDmc, attributes, restart, rm));

    }

    /**

     * This method indicates if we should use the -exec-continue method

     * instead of the -exec-run method.

     * This can be overridden to allow for customization.

     */

    protected boolean useContinueCommand(Map<String, Object> attributes, boolean restart) {

    	// When doing remote debugging, we use -exec-continue instead of -exec-run

    	// Restart does not apply to remote sessions

    	return fBackend.getSessionType() == SessionType.REMOTE;

    }

import java.util.HashMap;

import java.util.Map;

import org.eclipse.debug.core.Launch;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.PlatformUI;

    private final Launch fLaunch;

        fLaunch = launch;

    			// Add an entry to create a new process

    			IProcessExtendedInfo[] newArray = new IProcessExtendedInfo[fProcessList.length + 1];

    			System.arraycopy(fProcessList, 0, newArray, 1, fProcessList.length);

    			newArray[0] = new ProcessInfo(-1, "! <Create new process> !");

    			fProcessList = newArray;

																if (getData() == -1) {

																	// We want to create a new process instead

																	Map<String, Object> attributes = new HashMap<String, Object>();

																	try {

																		attributes = fLaunch.getLaunchConfiguration().getAttributes();

																	} catch (CoreException e) {

																	}

																	final String[] binaryPath = new String[1];

																	PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {

																		public void run() {

																	   		Shell shell = Display.getDefault().getActiveShell();		

																    		if (shell == null) {

																    			return;

																    		}

																    		FileDialog fd = new FileDialog(shell, SWT.SAVE);

																    		binaryPath[0] = fd.open();

																    	}

																	});

																	procService.debugNewProcess(controlCtx, 

																			                    binaryPath[0],

																			                    attributes, 

																			                    new DataRequestMonitor<IDMContext>(fExecutor, rm));

																	return;

																}

															} else {

																rm.done();