/*******************************************************************************
 * Copyright (c) 2005 The Regents of the University of California. 
 * This material was produced under U.S. Government contract W-7405-ENG-36 
 * for Los Alamos National Laboratory, which is operated by the University 
 * of California for the U.S. Department of Energy. The U.S. Government has 
 * rights to use, reproduce, and distribute this software. NEITHER THE 
 * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR 
 * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified 
 * to produce derivative works, such modified software should be clearly marked, 
 * so as not to confuse it with the version available from LANL.
 * 
 * Additionally, 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
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * LA-CC 04-115
 *******************************************************************************/
package org.eclipse.ptp.debug.core.pdi;

import java.util.Vector;
import java.util.concurrent.locks.ReentrantLock;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.ptp.core.util.BitList;
import org.eclipse.ptp.debug.core.PDebugUtils;
import org.eclipse.ptp.debug.core.PTPDebugCorePlugin;
import org.eclipse.ptp.debug.core.pdi.event.IPDIEventFactory;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIBreakpointManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIEventManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIEventRequestManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIExpressionManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIManagerFactory;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIRegisterManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDISignalManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDISourceManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDITargetManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDITaskManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIThreadManager;
import org.eclipse.ptp.debug.core.pdi.manager.IPDIVariableManager;
import org.eclipse.ptp.debug.core.pdi.model.IPDIModelFactory;
import org.eclipse.ptp.debug.core.pdi.model.IPDISignal;
import org.eclipse.ptp.debug.core.pdi.model.IPDITarget;
import org.eclipse.ptp.debug.core.pdi.model.IPDIThread;
import org.eclipse.ptp.debug.core.pdi.model.aif.IAIF;
import org.eclipse.ptp.debug.core.pdi.request.IPDIRequestFactory;
import org.eclipse.ptp.debug.core.pdi.request.IPDIStartDebuggerRequest;

/**
 * @author clement
 *
 */
public class Session implements IPDISession {
	private IPDIBreakpointManager breakpointManager;
	private IPDIEventManager eventManager;
	private IPDIEventRequestManager eventRequestManager;
	private IPDITaskManager taskManager;
	private IPDITargetManager targetManager; 
	private IPDIThreadManager threadManager; 
	private IPDIExpressionManager expressionManager;
	private IPDIVariableManager variableManager;
	private IPDISourceManager sourceManager;
	private IPDIMemoryManager memoryManager;
	private IPDISignalManager signalManager;
	private IPDIRegisterManager registerManager;
	private IPDIDebugger debugger = null;
	private String job_id;
	private int total_tasks = 0;
	private int status;
	private long timeout = 30000;
	private NotifyJob notifyJob = null;
	private IPDIRequestFactory requestFactory;
	private IPDIEventFactory eventFactory;
	private IPDIModelFactory modelFactory;
	private final ReentrantLock	waitLock = new ReentrantLock();
	private ILaunchConfiguration config = null;
	
	public Session(IPDIManagerFactory managerFactory,IPDIRequestFactory requestFactory, 
			IPDIEventFactory eventFactory, IPDIModelFactory modelFactory, 
			ILaunchConfiguration config, long timeout, IPDIDebugger debugger, 
			String job_id, int total_tasks) throws PDIException {
		this.config = config;
		this.timeout = timeout;
		this.debugger = debugger;
		this.job_id = job_id;
		this.total_tasks = total_tasks;
		this.notifyJob = new NotifyJob();
		this.requestFactory = requestFactory;
		this.eventFactory = eventFactory;
		this.modelFactory = modelFactory;
		
		setEventRequestManager(managerFactory.newEventRequestManager(this));
		setEventManager(managerFactory.newEventManager(this));
		setTaskManager(managerFactory.newTaskManager(this));
		setTargetManager(managerFactory.newTargetManager(this));
		setThreadManager(managerFactory.newThreadManager(this));
		setBreakpointManager(managerFactory.newBreakpointManager(this));
		setExpressionManager(managerFactory.newExpressionManager(this));
		setVariableManager(managerFactory.newVariableManager(this));
		setSourceManager(managerFactory.newSourceManager(this));
		setMemeoryManager(managerFactory.newMemoryManager(this));
		setSignalManager(managerFactory.newSignalManager(this));
		setRegisterManager(managerFactory.newRegisterManager(this));
	}
	
	/**
	 * @return
	 */
	public ILaunchConfiguration getConfiguration() {
		return config;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getRequestFactory()
	 */
	public IPDIRequestFactory getRequestFactory() {
		return requestFactory;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getTimeout()
	 */
	public long getTimeout() {
		return timeout;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#setRequestTimeout(long)
	 */
	public void setRequestTimeout(long timeout) {
		this.timeout = timeout;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#connectToDebugger(org.eclipse.core.runtime.IProgressMonitor, java.lang.String, java.lang.String, java.lang.String, java.lang.String[])
	 */
	public void connectToDebugger(IProgressMonitor monitor, String app, String path, String dir, String[] args) throws PDIException {
		setStatus(CONNECTING);
		if (!getDebugger().isConnected(monitor)) {
			throw new PDIException(getTasks(), "Cannot connect to debugger");
		}
		getDebugger().register(eventManager);
		monitor.beginTask("Initialising debug processes ("+total_tasks+")...", total_tasks);
		IPDIStartDebuggerRequest request = getRequestFactory().getStartDebuggerRequest(getTasks(), app, path, dir, args);
		eventRequestManager.addEventRequest(request);
		request.waitUntilCompleted(null, monitor);
		setStatus(CONNECTED);
		eventManager.fireEvent(getEventFactory().newStartedEvent(this, getTasks()));
	}
	
	/**
	 * @param manager
	 */
	protected void setEventRequestManager(IPDIEventRequestManager manager) {
		eventRequestManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setEventManager(IPDIEventManager manager) {
		eventManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setTaskManager(IPDITaskManager manager) {
		taskManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setTargetManager(IPDITargetManager manager) {
		targetManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setThreadManager(IPDIThreadManager manager) {
		threadManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setBreakpointManager(IPDIBreakpointManager manager) {
		breakpointManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setExpressionManager(IPDIExpressionManager manager) {
		expressionManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setVariableManager(IPDIVariableManager manager) {
		variableManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setSourceManager(IPDISourceManager manager) {
		sourceManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setMemeoryManager(IPDIMemoryManager manager) {
		memoryManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setSignalManager(IPDISignalManager manager) {
		signalManager = manager;
	}
	
	/**
	 * @param manager
	 */
	protected void setRegisterManager(IPDIRegisterManager manager) {
		registerManager = manager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getEventRequestManager()
	 */
	public IPDIEventRequestManager getEventRequestManager() {
		return eventRequestManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getEventManager()
	 */
	public IPDIEventManager getEventManager() {
		return eventManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getTaskManager()
	 */
	public IPDITaskManager getTaskManager() {
		return taskManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getThreadManager()
	 */
	public IPDIThreadManager getThreadManager() {
		return threadManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getTargetManager()
	 */
	public IPDITargetManager getTargetManager() {
		return targetManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getBreakpointManager()
	 */
	public IPDIBreakpointManager getBreakpointManager() {
		return breakpointManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getExpressionManager()
	 */
	public IPDIExpressionManager getExpressionManager() {
		return expressionManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getVariableManager()
	 */
	public IPDIVariableManager getVariableManager() {
		return variableManager;
	}
	
	/**
	 * @return
	 */
	public IPDISourceManager getSourceManager() {
		return sourceManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getMemoryManager()
	 */
	public IPDIMemoryManager getMemoryManager() {
		return memoryManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getSignalManager()
	 */
	public IPDISignalManager getSignalManager() {
		return signalManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getRegisterManager()
	 */
	public IPDIRegisterManager getRegisterManager() {
		return registerManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#shutdown(boolean)
	 */
	public void shutdown(boolean force) {
		try {
			if (!force) {
				exit();
			}
			else
				setStatus(EXITING);
			debugger.disconnect(eventManager);
		}
		catch (PDIException e) {
			e.printStackTrace();
		}
		finally {
			variableManager.shutdown();
			expressionManager.shutdown();
			breakpointManager.shutdown();
			eventManager.shutdown();
			sourceManager.shutdown();
			taskManager.shutdown();
			targetManager.shutdown();
			threadManager.shutdown();
			memoryManager.shutdown();
			signalManager.shutdown();
			eventRequestManager.shutdown();
			notifyJob.schedule();
		}
	}
	
	/*******************************************
	 * IPDIExecuteManagement
	 *******************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#restart(org.eclipse.ptp.core.util.BitList)
	 */
	public void restart(BitList tasks) throws PDIException {
		checkStatus();
		throw new PDIException(tasks, "Not implement restart() yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#start(org.eclipse.ptp.core.util.BitList)
	 */
	public void start(BitList tasks) throws PDIException {
		checkStatus();
		getEventRequestManager().addEventRequest(getRequestFactory().getResumeRequest(tasks, false));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#resume(org.eclipse.ptp.core.util.BitList, boolean)
	 */
	public void resume(BitList tasks, boolean passSignal) throws PDIException {
		checkStatus();
		if (passSignal)
			throw new PDIException(tasks, "Not implment resume() - Pass Signal yet");
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		getEventRequestManager().addEventRequest(getRequestFactory().getResumeRequest(tasks, passSignal));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#resume(org.eclipse.ptp.core.util.BitList, org.eclipse.ptp.debug.core.pdi.IPDILocation)
	 */
	public void resume(BitList tasks, IPDILocation location) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		throw new PDIException(tasks, "Not implment resume(IPDILocation) yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#resume(org.eclipse.ptp.core.util.BitList, org.eclipse.ptp.debug.core.pdi.model.IPDISignal)
	 */
	public void resume(BitList tasks, IPDISignal signal) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		throw new PDIException(tasks, "Not implment resume(IPDISignal) yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepInto(org.eclipse.ptp.core.util.BitList, int)
	 */
	public void stepInto(BitList tasks, int count) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		getEventRequestManager().addEventRequest(getRequestFactory().getStepIntoRequest(tasks, count));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepIntoInstruction(org.eclipse.ptp.core.util.BitList, int)
	 */
	public void stepIntoInstruction(BitList tasks, int count) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		throw new PDIException(tasks, "Not implment stepIntoInstruction() yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepOver(org.eclipse.ptp.core.util.BitList, int)
	 */
	public void stepOver(BitList tasks, int count) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		getEventRequestManager().addEventRequest(getRequestFactory().getStepOverRequest(tasks, count));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepOverInstruction(org.eclipse.ptp.core.util.BitList, int)
	 */
	public void stepOverInstruction(BitList tasks, int count) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		throw new PDIException(tasks, "Not implment stepOverInstruction() yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepReturn(org.eclipse.ptp.core.util.BitList, org.eclipse.ptp.debug.core.pdi.model.aif.IAIF)
	 */
	public void stepReturn(BitList tasks, IAIF aif) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		throw new PDIException(tasks, "Not implment stepReturn(IAIF) yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepReturn(org.eclipse.ptp.core.util.BitList, int)
	 */
	public void stepReturn(BitList tasks, int count) throws PDIException {
		checkStatus();
		taskManager.getCanStepReturnTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		getEventRequestManager().addEventRequest(getRequestFactory().getStepFinishRequest(tasks, count));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#stepUntil(org.eclipse.ptp.core.util.BitList, org.eclipse.ptp.debug.core.pdi.IPDILocation)
	 */
	public void stepUntil(BitList tasks, IPDILocation location) throws PDIException {
		checkStatus();
		taskManager.getSuspendedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No suspended processes found");
		throw new PDIException(tasks, "Not implment stepUntil(IPDILocation) yet");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#suspend(org.eclipse.ptp.core.util.BitList)
	 */
	public void suspend(BitList tasks) throws PDIException {
		checkStatus();
		taskManager.getRunningTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "No running processes found");
		getEventRequestManager().addEventRequest(getRequestFactory().getSuspendRequest(tasks));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDIExecuteManagement#terminate(org.eclipse.ptp.core.util.BitList)
	 */
	public void terminate(BitList tasks) throws PDIException {
		checkStatus();
		taskManager.getNonTerminatedTasks(tasks);
		if (tasks.isEmpty())
			throw new PDIException(tasks, "All processes have been terminated");

		BitList nonTerTasks = tasks.copy();
		taskManager.getRunningTasks(nonTerTasks);
		if (!nonTerTasks.isEmpty()) {
			getEventRequestManager().addEventRequest(getRequestFactory().getSuspendRequest(nonTerTasks, false));
		}
		getEventRequestManager().addEventRequest(getRequestFactory().getTerminateRequest(tasks));
		taskManager.setPendingTasks(true, tasks);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#validateStepReturn(org.eclipse.ptp.core.util.BitList)
	 */
	public void validateStepReturn(BitList tasks) throws PDIException {
		/*
		taskManager.getUnregisteredTasks(tasks);
		if (!tasks.isEmpty()) {
			getEventRequestManager().addEventRequest(getRequestFactory().getGetStackInfoDepthRequest(tasks));
			//FIXME: for testing
			//getEventRequestManager().addEventRequest(getRequestFactory().getTerminateRequest(tasks.copy()));
		}
		*/
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#exit()
	 */
	public void exit() throws PDIException {
		if (status != EXITING && status != EXITED) {
			setStatus(EXITING);
			eventRequestManager.cleanEventRequests();
			BitList tasks = getTasks();
			taskManager.getRunningTasks(tasks);
			if (!tasks.isEmpty()) {
				getEventRequestManager().addEventRequest(getRequestFactory().getSuspendRequest(tasks, false));
			}
			tasks = getTasks();
			taskManager.getNonTerminatedTasks(tasks);
			if (!tasks.isEmpty())
				getEventRequestManager().addEventRequest(getRequestFactory().getTerminateRequest(tasks));
			
			getEventRequestManager().addEventRequest(getRequestFactory().getStopDebuggerRequest(new BitList(total_tasks)));
			taskManager.setPendingTasks(true, tasks);
		}
	}
	
	/*******************************************
	 * IPDISession
	 *******************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getDebugger()
	 */
	public IPDIDebugger getDebugger() {
		return debugger;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getJobID()
	 */
	public String getJobID() {
		return job_id;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#isTerminated(org.eclipse.ptp.core.util.BitList)
	 */
	public boolean isTerminated(BitList tasks) {
		return taskManager.isAllTerminated(tasks);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#isSuspended(org.eclipse.ptp.core.util.BitList)
	 */
	public boolean isSuspended(BitList tasks) {
		return taskManager.isAllSuspended(tasks);
	}
	
	/**
	 * @param tasks
	 * @return
	 */
	public boolean isRunning(BitList tasks) {
		return taskManager.isAllRunning(tasks);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getTasks()
	 */
	public BitList getTasks() {
		BitList tasks = new BitList(total_tasks);
		tasks.set(0, total_tasks);
		return tasks;
	}	
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getTotalTasks()
	 */
	public int getTotalTasks() {
		return total_tasks;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISessionObject#getSession()
	 */
	public IPDISession getSession() {
		return this;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#setStatus(int)
	 */
	public void setStatus(int status) {
		waitLock.lock();
		try {
			this.status = status;
		}
		finally {
			waitLock.unlock();
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getStatus()
	 */
	public int getStatus() {
		return status;
	}
	
	/**
	 * @throws PDIException
	 */
	protected void checkStatus() throws PDIException {
		if (status == EXITING || status == EXITED)
			throw new PDIException(null, "Cannot process for your request due to session is exiting or exited.");
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#findTarget(org.eclipse.ptp.core.util.BitList)
	 */
	public IPDITarget findTarget(BitList qTasks) throws PDIException {
		IPDITarget target = targetManager.getTarget(qTasks);
		if (target == null)
			throw new PDIException(qTasks, "No target found.");
		return target;
	}
	
	/**
	 * @param qTasks
	 * @return
	 */
	public boolean isTarget(BitList qTasks) {
		return (targetManager.getTarget(qTasks) != null);
	}
	
	/**********************************************
	 * process on running or suspended 
	 **********************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#processRunningEvent(org.eclipse.ptp.core.util.BitList)
	 */
	public synchronized void processRunningEvent(BitList tasks) {
		IPDITarget[] targets = targetManager.getTargets();
		for (final IPDITarget target : targets) {
			if (target.getTasks().intersects(tasks)) {
				Runnable runnable = new Runnable() {
					public void run() {
						target.setSupended(false);
					}
				};
				queueRunnable(runnable);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#processSupsendedEvent(org.eclipse.ptp.core.util.BitList, int, java.lang.String[])
	 */
	public synchronized void processSupsendedEvent(BitList tasks, final int thread_id, final String[] vars) {
		IPDITarget[] targets = targetManager.getTargets();
		for (final IPDITarget target : targets) {
			if (target.getTasks().intersects(tasks)) {
				Runnable runnable = new Runnable() {
					public void run() {
						target.setSupended(true);
						target.updateState(thread_id);
						try {
							IPDIThread pthread = target.getCurrentThread();
							if (pthread == null)
								return;
							
							pthread.getCurrentStackFrame();
						} catch (PDIException e) {
							return;
						}

						try {
							if (variableManager.isAutoUpdate()) {
								variableManager.update(target.getTasks(), vars);
							}
							if (expressionManager.isAutoUpdate()) { 
								expressionManager.update(target.getTasks(), vars);
							}
							if (registerManager.isAutoUpdate()) {
								registerManager.update(target.getTasks());
							}
							if (memoryManager.isAutoUpdate()) {
								memoryManager.update(target.getTasks());
							}
							if (breakpointManager.isAutoUpdate()) {
								breakpointManager.update(target.getTasks());
							}
							if (signalManager.isAutoUpdate()) {
								signalManager.update(target.getTasks());
							}
							if (sourceManager.isAutoUpdate()) {
								sourceManager.update(target.getTasks());
							}
						} catch (PDIException e) {
							return;
						}
					}
				};
				queueRunnable(runnable);
			}
		}
	}
	
	/*************************************************
	 * Notify Job
	 *************************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#queueRunnable(java.lang.Runnable)
	 */
	public void queueRunnable(Runnable runnable) {
		notifyJob.addRunnable(runnable);
	}
	
	class NotifyJob extends Job {
		private Vector<Runnable> fRunnables;
		public NotifyJob() {
			super("PTP Notify Job");
			setSystem(true);
			fRunnables = new Vector<Runnable>(10);
		}
		public void addRunnable(Runnable runnable) {
			synchronized (fRunnables) {
				fRunnables.add(runnable);
			}
			schedule();
		}
		public boolean shouldRun() {
			return !fRunnables.isEmpty();
		}
		public IStatus run(IProgressMonitor monitor) {
			Runnable[] runnables;
			synchronized (fRunnables) {
				runnables = fRunnables.toArray(new Runnable[0]);
				fRunnables.clear();
			}
			MultiStatus failed = null;
			monitor.beginTask(getName(), runnables.length);
			PDebugUtils.println("Msg: NotifyJob - size of runnables: " + runnables.length);
			for (Runnable runnable : runnables) {
				try {
					runnable.run();
				}
				catch (Exception e) {
					if (failed == null)
						failed = new MultiStatus(PTPDebugCorePlugin.getUniqueIdentifier(), PTPDebugCorePlugin.INTERNAL_ERROR, "Event notify error", null);
					failed.add(new Status(IStatus.ERROR, PTPDebugCorePlugin.getUniqueIdentifier(), PTPDebugCorePlugin.INTERNAL_ERROR, "Event notify error", e));
				}
				monitor.worked(1);
			}
			monitor.done();
			if (failed == null)
				return Status.OK_STATUS;
			
			return failed;
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getEventFactory()
	 */
	public IPDIEventFactory getEventFactory() {
		return eventFactory;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.IPDISession#getModelFactory()
	 */
	public IPDIModelFactory getModelFactory() {
		return modelFactory;
	}
}