/*******************************************************************************
 * 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.internal.core;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.ptp.core.IPTPLaunchConfigurationConstants;
import org.eclipse.ptp.core.attributes.IAttribute;
import org.eclipse.ptp.core.elementcontrols.IPJobControl;
import org.eclipse.ptp.core.elementcontrols.IPProcessControl;
import org.eclipse.ptp.core.elements.IPJob;
import org.eclipse.ptp.core.elements.IPProcess;
import org.eclipse.ptp.core.elements.attributes.ProcessAttributes;
import org.eclipse.ptp.core.util.BitList;
import org.eclipse.ptp.debug.core.IPBreakpointManager;
import org.eclipse.ptp.debug.core.IPMemoryManager;
import org.eclipse.ptp.debug.core.IPRegisterManager;
import org.eclipse.ptp.debug.core.IPSession;
import org.eclipse.ptp.debug.core.IPSetManager;
import org.eclipse.ptp.debug.core.IPSignalManager;
import org.eclipse.ptp.debug.core.PTPDebugCorePlugin;
import org.eclipse.ptp.debug.core.event.IPDebugEvent;
import org.eclipse.ptp.debug.core.event.IPDebugInfo;
import org.eclipse.ptp.debug.core.event.PDebugErrorInfo;
import org.eclipse.ptp.debug.core.event.PDebugEvent;
import org.eclipse.ptp.debug.core.event.PDebugExitInfo;
import org.eclipse.ptp.debug.core.event.PDebugInfo;
import org.eclipse.ptp.debug.core.event.PDebugSuspendInfo;
import org.eclipse.ptp.debug.core.launch.IPLaunch;
import org.eclipse.ptp.debug.core.pdi.IPDILocator;
import org.eclipse.ptp.debug.core.pdi.IPDISession;
import org.eclipse.ptp.debug.core.pdi.IPDISessionObject;
import org.eclipse.ptp.debug.core.pdi.PDIException;
import org.eclipse.ptp.debug.core.pdi.event.IPDIBreakpointInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIChangedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIConnectedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDICreatedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIDestroyedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIDisconnectedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIEndSteppingRangeInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIErrorEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIErrorInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIEventListener;
import org.eclipse.ptp.debug.core.pdi.event.IPDIExitInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIFunctionFinishedInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDILocationReachedInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIMemoryBlockInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIRegisterInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIRestartedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIResumedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDISharedLibraryInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDISignalInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIStartedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDISuspendedEvent;
import org.eclipse.ptp.debug.core.pdi.event.IPDIThreadInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIVariableInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIWatchpointScopeInfo;
import org.eclipse.ptp.debug.core.pdi.event.IPDIWatchpointTriggerInfo;
import org.eclipse.ptp.debug.core.pdi.manager.IPDITaskManager;
import org.eclipse.ptp.debug.core.pdi.model.IPDIBreakpoint;
import org.eclipse.ptp.debug.core.pdi.model.IPDILocationBreakpoint;
import org.eclipse.ptp.debug.core.pdi.model.IPDITarget;
import org.eclipse.ptp.debug.internal.core.model.PDebugTarget;

public class PSession implements IPSession, IPDIEventListener {
	private final IPDISession pdiSession;
	private final IPLaunch launch;
	private final IProject project;
	private final PSignalManager signalMgr;
	private final PBreakpointManager bptMgr;
	private final PMemoryManager memMgr;
	private final PRegisterManager regMgr;
	private final PSetManager setMgr;

	public PSession(IPDISession pdiSession, IPLaunch launch, IProject project) {
		this.pdiSession = pdiSession;
		this.launch = launch;
		this.project = project;
		signalMgr = new PSignalManager(this);
		bptMgr = new PBreakpointManager(this);
		memMgr = new PMemoryManager(this);
		regMgr = new PRegisterManager(this);
		setMgr = new PSetManager(this);
		getPDISession().getEventManager().addEventListener(this);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#dispose()
	 */
	public void dispose() {
		dispose(false);
	}
	
	/**
	 * @param force
	 */
	private void dispose(final boolean force) {
		WorkspaceJob aJob = new WorkspaceJob("Disposing session...") {
			public IStatus runInWorkspace(IProgressMonitor monitor) {
				signalMgr.dispose(monitor);
				bptMgr.dispose(monitor);
				memMgr.dispose(monitor);
				regMgr.dispose(monitor);
				setMgr.dispose(monitor);
				deleteDebugTargets(true);
				getPDISession().getEventManager().removeEventListener(PSession.this);
				getPDISession().shutdown(force);
				return Status.OK_STATUS;
			}
		};
		aJob.setSystem(true);
		aJob.schedule();		
	}
	
	/**
	 * @param monitor
	 * @throws CoreException
	 */
	public void connectToDebugger(IProgressMonitor monitor, String app, String path, String cwd, String[] args) throws CoreException {
		if (monitor == null) {
			monitor = new NullProgressMonitor();
		}
		boolean failed = false;
		try {
			getPDISession().connectToDebugger(monitor, app, path, cwd, args);
		} catch (PDIException e) {
			failed = true;
			throw new CoreException(new Status(IStatus.ERROR, PTPDebugCorePlugin.getUniqueIdentifier(), IStatus.ERROR, e.getMessage(), null));			
		}
		finally {
			if (failed || monitor.isCanceled()) {
				dispose();
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getSetManager()
	 */
	public IPSetManager getSetManager() {
		return setMgr;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getSignalManager()
	 */
	public IPSignalManager getSignalManager() {
		return signalMgr;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getBreakpointManager()
	 */
	public IPBreakpointManager getBreakpointManager() {
		return bptMgr;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getRegisterManager()
	 */
	public IPRegisterManager getRegisterManager() {
		return regMgr;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getMemoryManager()
	 */
	public IPMemoryManager getMemoryManager() {
		return memMgr;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	@SuppressWarnings("unchecked")
	public Object getAdapter(Class adapter) {
		if (adapter.equals(IPDISession.class))
			return this;
		if (adapter.equals(PSignalManager.class))
			return getSignalManager();
		return null;
	}
	
	/**
	 * @param eTasks
	 * @return
	 */
	public IPDebugInfo getDebugInfo(BitList eTasks) {
		IPDITaskManager taskMgr = getPDISession().getTaskManager();
		return new PDebugInfo(getJob(), eTasks, taskMgr.getRegisteredTasks(eTasks.copy()), taskMgr.getUnregisteredTasks(eTasks.copy()));
	}
	
	/****************************************
	 * IPDIEventListener
	 ****************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.pdi.event.IPDIEventListener#handleDebugEvents(org.eclipse.ptp.debug.core.pdi.event.IPDIEvent[])
	 */
	public void handleDebugEvents(IPDIEvent[] events) {
		for (IPDIEvent event : events) {
			if (event instanceof IPDIConnectedEvent) {
				PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(getSession(), IPDebugEvent.CREATE, IPDebugEvent.DEBUGGER, getDebugInfo(event.getTasks())));
			} else if (event instanceof IPDIStartedEvent) {
				//only call once
				bptMgr.setInitialBreakpoints();
				boolean stopInMain = true;
				try {
					stopInMain = getLaunch().getLaunchConfiguration().getAttribute(IPTPLaunchConfigurationConstants.ATTR_STOP_IN_MAIN, false);		
				}
				catch (CoreException e) {
					//do nothing
				}
				try {
					if (stopInMain) {
						bptMgr.setStopInMain(getPDISession().getTasks());
					}
					getPDISession().start(getPDISession().getTasks());
					getPDISession().setStatus(IPDISession.STARTED);
					PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(getSession(), IPDebugEvent.CHANGE, IPDebugEvent.PROCESS_SPECIFIC, getDebugInfo(event.getTasks())));
				} catch (PDIException e) {
					IPDebugInfo errInfo = new PDebugErrorInfo(getDebugInfo(event.getTasks()), "Starting processes error!", e.getMessage(), PTPDebugCorePlugin.INTERNAL_ERROR);
					PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.ERROR, IPDebugEvent.UNSPECIFIED, errInfo));		
				}
			} else if (event instanceof IPDIDisconnectedEvent) {
				PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(getSession(), IPDebugEvent.TERMINATE, IPDebugEvent.DEBUGGER, getDebugInfo(event.getTasks())));				
				dispose();
			} else if (event instanceof IPDIChangedEvent) {
				fireChangeEvent((IPDIChangedEvent)event);
			} else if (event instanceof IPDICreatedEvent) {
				fireCreateEvent((IPDICreatedEvent)event);
			} else if (event instanceof IPDIDestroyedEvent) {
				fireDestroyEvent((IPDIDestroyedEvent)event);
			} else if (event instanceof IPDIErrorEvent) {
				fireErrorEvent((IPDIErrorEvent)event);
			} else if (event instanceof IPDIRestartedEvent) {
				//TODO
			} else if (event instanceof IPDIResumedEvent) {
				fireResumeEvent((IPDIResumedEvent)event);
			} else if (event instanceof IPDISuspendedEvent) {
				try {
					bptMgr.updatePendingBreakpoints();
				} catch (PDIException e) {
				}
				fireSuspendEvent((IPDISuspendedEvent)event);
			} else {
				IPDebugEvent debugEvent = new PDebugEvent(this, IPDebugEvent.UNSPECIFIED, IPDebugEvent.UNSPECIFIED, getDebugInfo(event.getTasks()));		
				PTPDebugCorePlugin.getDefault().fireDebugEvent(debugEvent);
			}
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#forceStoppedDebugger(org.eclipse.ptp.core.elements.attributes.ProcessAttributes.State)
	 */
	public void forceStoppedDebugger(ProcessAttributes.State state) {
		BitList tasks = getTasks();
		changeProcessState(tasks, state);
		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(getSession(), IPDebugEvent.TERMINATE, IPDebugEvent.DEBUGGER, getDebugInfo(tasks)));
		dispose(true);
	}
	
	/**
	 * @param tasks
	 * @param state
	 */
	private void changeProcessState(BitList tasks, ProcessAttributes.State state) {
		IPJob job = getJob();
		List<IPProcessControl> processes = new ArrayList<IPProcessControl>();
		for (int task : tasks.toArray()) {
			IPProcess p = job.getProcessByIndex(task);
			if (p instanceof IPProcessControl) {
				processes.add((IPProcessControl)p);
			}
		}
		((IPJobControl)job).addProcessAttributes(processes, new IAttribute[] { ProcessAttributes.getStateAttributeDefinition().create(state) });
	}
	
	/**
	 * @param event
	 */
	public void fireSuspendEvent(IPDISuspendedEvent event) {
		/*
		try {
			getPDISession().validateStepReturn(event.getTasks().copy());
		}
		catch (PDIException e) {
			IPDebugInfo errInfo = new PDebugErrorInfo(getDebugInfo(e.getTasks()), "Check step return error!", e.getMessage(), PTPDebugCorePlugin.INTERNAL_ERROR);
			PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.ERROR, IPDebugEvent.UNSPECIFIED, errInfo));		
		}
		*/
		IPDebugInfo baseInfo = getDebugInfo(event.getTasks());
		int detail = IPDebugEvent.UNSPECIFIED;
		
		int lineNumber = 0;
		int level = event.getLevel();
		int depth = event.getDepth();
		String fileName = "";
		IPDISessionObject reason = event.getReason();
		if (reason instanceof IPDIBreakpointInfo) {
			IPDIBreakpoint bpt = ((IPDIBreakpointInfo)reason).getBreakpoint();
			if (bpt instanceof IPDILocationBreakpoint) {
				IPDILocator locator = ((IPDILocationBreakpoint) bpt).getLocator();
				if (locator != null) {
					lineNumber = locator.getLineNumber();
					fileName += locator.getFile();
					detail = IPDebugEvent.BREAKPOINT;
				}
			}
		} else if (reason instanceof IPDIEndSteppingRangeInfo) {
			IPDILocator locator = ((IPDIEndSteppingRangeInfo)reason).getLocator();
			if (locator != null) {
				lineNumber = locator.getLineNumber();
				fileName += locator.getFile();
				detail = IPDebugEvent.STEP_END;
			}
		} else if (reason instanceof IPDILocationReachedInfo) {
			IPDILocator locator = ((IPDILocationReachedInfo)reason).getLocator();
			if (locator != null) {
				lineNumber = locator.getLineNumber();
				fileName += locator.getFile();
				detail = IPDebugEvent.CLIENT_REQUEST;
			}
		} else if (reason instanceof IPDISignalInfo) {
			IPDILocator locator = ((IPDISignalInfo)reason).getLocator();
			if (locator != null) {
				lineNumber = locator.getLineNumber();
				fileName += locator.getFile();
				detail = IPDebugEvent.CLIENT_REQUEST;
			}
		} else if (reason instanceof IPDIFunctionFinishedInfo) {
			//TODO
		} else if (reason instanceof IPDISharedLibraryInfo) {
			//TODO
		} else if (reason instanceof IPDIWatchpointScopeInfo) {
			//TODO
		} else if (reason instanceof IPDIWatchpointTriggerInfo) {
			//TODO
		}
		changeProcessState(event.getTasks(), ProcessAttributes.State.SUSPENDED);
		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(getSession(), IPDebugEvent.SUSPEND, detail, new PDebugSuspendInfo(baseInfo, fileName, lineNumber, level, depth)));
	}
	
	/**
	 * @param event
	 */
	public void fireResumeEvent(IPDIResumedEvent event) {
		IPDebugInfo baseInfo = getDebugInfo(event.getTasks());
		int detail = IPDebugEvent.UNSPECIFIED;

		switch (event.getType()) {
		case IPDIResumedEvent.STEP_INTO:
		case IPDIResumedEvent.STEP_INTO_INSTRUCTION:
			detail = IPDebugEvent.STEP_INTO;
			break;
		case IPDIResumedEvent.STEP_OVER:
		case IPDIResumedEvent.STEP_OVER_INSTRUCTION:
			detail = IPDebugEvent.STEP_OVER;
			break;
		case IPDIResumedEvent.STEP_RETURN:
			detail = IPDebugEvent.STEP_RETURN;
			break;
		}

		changeProcessState(event.getTasks(), ProcessAttributes.State.RUNNING);

		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.RESUME, detail, baseInfo));
	}
	
	/**
	 * @param event
	 */
	public void fireDestroyEvent(IPDIDestroyedEvent event) {
		IPDebugEvent debugEvent = null;
		IPDebugInfo baseInfo = getDebugInfo(event.getTasks());
		IPDISessionObject reason = event.getReason();

		if (reason instanceof IPDIBreakpointInfo) {
		} else if (reason instanceof IPDIErrorInfo) {
			deleteDebugTarget(baseInfo.getAllRegisteredTasks().copy(), true, true);
			IPDebugInfo errInfo = new PDebugErrorInfo(baseInfo, ((IPDIErrorInfo)reason).getMessage(), ((IPDIErrorInfo)reason).getDetailMessage(), ((IPDIErrorInfo)reason).getCode());
			debugEvent = new PDebugEvent(this, IPDebugEvent.TERMINATE, IPDebugEvent.ERROR, errInfo);
			changeProcessState(event.getTasks(), ProcessAttributes.State.ERROR);
		} else if (reason instanceof IPDIExitInfo) {
			deleteDebugTarget(baseInfo.getAllRegisteredTasks().copy(), true, true);
			IPDebugInfo exitInfo = new PDebugExitInfo(baseInfo, ((IPDIExitInfo)reason).getCode(), "Exited", "Exited");
			debugEvent = new PDebugEvent(this, IPDebugEvent.TERMINATE, IPDebugEvent.PROCESS_SPECIFIC, exitInfo);
			changeProcessState(event.getTasks(), ProcessAttributes.State.EXITED);
		} else if (reason instanceof IPDISignalInfo) {
			deleteDebugTarget(baseInfo.getAllRegisteredTasks().copy(), true, true);
			IPDebugInfo exitInfo = new PDebugExitInfo(baseInfo, 0, ((IPDISignalInfo)reason).getDescription(), ((IPDISignalInfo)reason).getName());
			debugEvent = new PDebugEvent(this, IPDebugEvent.TERMINATE, IPDebugEvent.PROCESS_SPECIFIC, exitInfo);
			changeProcessState(event.getTasks(), ProcessAttributes.State.EXITED_SIGNALLED);
		} else if (reason instanceof IPDISharedLibraryInfo) {
			//TODO
		} else if (reason instanceof IPDIThreadInfo) {
			//TODO
		} else if (reason instanceof IPDIVariableInfo) {
			//TODO
		} else {
			debugEvent = new PDebugEvent(this, IPDebugEvent.TERMINATE, IPDebugEvent.UNSPECIFIED, baseInfo);		
		}
		PTPDebugCorePlugin.getDefault().fireDebugEvent(debugEvent);
	}
	
	/**
	 * @param event
	 */
	public void fireErrorEvent(IPDIErrorEvent event) {
		IPDebugInfo baseInfo = getDebugInfo(event.getTasks());
		int detail = IPDebugEvent.UNSPECIFIED;
		IPDISessionObject reason = event.getReason();
		if (reason instanceof IPDIErrorInfo) {
			int code = ((IPDIErrorInfo)reason).getCode();
			switch (code) {
			case IPDIErrorInfo.DBG_FATAL:
				detail = IPDebugEvent.ERR_FATAL;
				//only fatal error reports process error
				changeProcessState(event.getTasks(), ProcessAttributes.State.ERROR);
				break;
			case IPDIErrorInfo.DBG_WARNING:
				detail = IPDebugEvent.ERR_WARNING;
				break;
			case IPDIErrorInfo.DBG_IGNORE:
			case IPDIErrorInfo.DBG_NORMAL:
				detail = IPDebugEvent.ERR_NORMAL;
				break;
			}
			IPDebugInfo errInfo = new PDebugErrorInfo(baseInfo, ((IPDIErrorInfo)reason).getMessage(), ((IPDIErrorInfo)reason).getDetailMessage(), ((IPDIErrorInfo)reason).getCode());			
			PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.ERROR, detail, errInfo));
		} else {
			IPDebugInfo errInfo = new PDebugErrorInfo(baseInfo, "Internal Error!", "Unknown", PTPDebugCorePlugin.INTERNAL_ERROR);
			PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.ERROR, IPDebugEvent.UNSPECIFIED, errInfo));		
		}
	}
	
	/**
	 * @param event
	 */
	public void fireChangeEvent(IPDIChangedEvent event) {
		IPDebugInfo baseInfo = getDebugInfo(event.getTasks());
		int detail = IPDebugEvent.UNSPECIFIED;
		
		IPDISessionObject reason = event.getReason();
		if (reason instanceof IPDIBreakpointInfo) {
		} else if (reason instanceof IPDIMemoryBlockInfo) {
			//TODO
		} else if (reason instanceof IPDISignalInfo) {
			//TODO
		} else if (reason instanceof IPDIVariableInfo) {
			//TODO
		}
		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.CHANGE, detail, baseInfo));
	}
	
	/**
	 * @param event
	 */
	public void fireCreateEvent(IPDICreatedEvent event) {
		IPDebugInfo baseInfo = getDebugInfo(event.getTasks());
		int detail = IPDebugEvent.UNSPECIFIED;

		IPDISessionObject reason = event.getReason();
		if (reason instanceof IPDIBreakpointInfo) {
		} else if (reason instanceof IPDIThreadInfo) {
		} else if (reason instanceof IPDIMemoryBlockInfo) {
		} else if (reason instanceof IPDIRegisterInfo) {
		} else if (reason instanceof IPDISharedLibraryInfo) {
		} else if (reason instanceof IPDIVariableInfo) {
		} else {
		}
		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, IPDebugEvent.CREATE, detail, baseInfo));
	}
	
	/**
	 * @param type
	 * @param details
	 * @param info
	 */
	public void fireDebugEvent(int type, int details, IPDebugInfo info) {
		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, type, details, info));
	}
	
	/**
	 * @param type
	 * @param details
	 * @param tasks
	 */
	public void fireDebugEvent(int type, int details, BitList tasks) {
		PTPDebugCorePlugin.getDefault().fireDebugEvent(new PDebugEvent(this, type, details, getDebugInfo(tasks)));
	}

	/**
	 * @return
	 */
	public IPSession getSession() {
		return this;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getPDISession()
	 */
	public IPDISession getPDISession() {
		return pdiSession;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getJob()
	 */
	public IPJob getJob() {
		return getLaunch().getPJob();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getLaunch()
	 */
	public IPLaunch getLaunch() {
		return launch;
	}
	
	/**
	 * @return
	 */
	public IProject getProject() {
		return project;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#findDebugTarget(org.eclipse.ptp.core.util.BitList)
	 */
	public PDebugTarget findDebugTarget(BitList tasks) {
		return (PDebugTarget)launch.getDebugTarget(tasks);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getTasks(int)
	 */
	public BitList getTasks(int id) {
		int max = getPDISession().getTotalTasks();
		BitList tasks = new BitList(max);
		if (id >= 0 && id <= max)
			tasks.set(id);
		return tasks;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#getTasks()
	 */
	public BitList getTasks() {
		return getPDISession().getTasks();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#isReady()
	 */
	public boolean isReady() {
		return (getPDISession().getStatus() == IPDISession.STARTED);
	}
	
	/****************************************
	 * register / unregister
	 ****************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#deleteDebugTargets(boolean)
	 */
	public void deleteDebugTargets(boolean register) {
		if (isReady()) {
			BitList tasks = getPDISession().getTaskManager().getRegisteredTasks().copy();
			deleteDebugTarget(tasks, true, register);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#reloadDebugTargets(org.eclipse.ptp.core.util.BitList, boolean, boolean)
	 */
	public void reloadDebugTargets(BitList tasks, boolean refresh, boolean register) {
		if (isReady()) {
			BitList curRegTasks = getPDISession().getTaskManager().getRegisteredTasks(tasks.copy());
			BitList othRegTasks = getPDISession().getTaskManager().getRegisteredTasks().copy();
			othRegTasks.andNot(curRegTasks);
			deleteDebugTarget(othRegTasks, refresh, register);
			createDebugTarget(curRegTasks, refresh, register);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#createDebugTarget(org.eclipse.ptp.core.util.BitList, boolean, boolean)
	 */
	public void createDebugTarget(BitList tasks, boolean refresh, boolean register) {
		if (isReady()) {
			List<IPDITarget> targets = new ArrayList<IPDITarget>();
			int[] task_array = tasks.toArray();
			for (int task_id : task_array) {
				IPDITarget target = getPDISession().getTargetManager().addTarget(getTasks(task_id));
				if (target != null) {
					targets.add(target);
				}
				else {
					tasks.clear(task_id);
				}
			}
			if (register)
				getPDISession().getTaskManager().setRegisterTasks(true, tasks);
			PTPDebugCorePlugin.getDebugModel().addNewDebugTargets(getLaunch(), tasks, targets.toArray(new IPDITarget[0]), refresh, false);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPSession#deleteDebugTarget(org.eclipse.ptp.core.util.BitList, boolean, boolean)
	 */
	public void deleteDebugTarget(BitList tasks, boolean refresh, boolean register) {
		int[] task_array = tasks.toArray();
		for (int task_id : task_array) {
			if (!getPDISession().getTargetManager().removeTarget(getTasks(task_id))) {
				tasks.clear(task_id);
			}
		}
		if (register)
			getPDISession().getTaskManager().setRegisterTasks(false, tasks);
		PTPDebugCorePlugin.getDebugModel().removeDebugTarget(getLaunch(), tasks, refresh);
	}
}