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

import java.util.Properties;
import org.eclipse.cdt.core.IBinaryParser.IBinaryObject;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.ptp.core.IPTPLaunchConfigurationConstants;
import org.eclipse.ptp.core.elements.IPJob;
import org.eclipse.ptp.core.util.BitList;
import org.eclipse.ptp.debug.core.IAbstractDebugger;
import org.eclipse.ptp.debug.core.PTPDebugCorePlugin;
import org.eclipse.ptp.debug.core.cdi.ICommandResult;
import org.eclipse.ptp.debug.core.cdi.IPCDIBreakpointManager;
import org.eclipse.ptp.debug.core.cdi.IPCDIEventManager;
import org.eclipse.ptp.debug.core.cdi.IPCDISession;
import org.eclipse.ptp.debug.core.cdi.IPCDISessionConfiguration;
import org.eclipse.ptp.debug.core.cdi.IPCDISessionObject;
import org.eclipse.ptp.debug.core.cdi.PCDIException;
import org.eclipse.ptp.debug.core.cdi.model.IPCDITarget;
import org.eclipse.ptp.debug.core.launch.IPLaunch;
import org.eclipse.ptp.debug.external.core.PTPDebugExternalPlugin;
import org.eclipse.ptp.debug.external.core.cdi.model.Target;
import org.eclipse.ptp.debug.external.core.commands.GetAIFCommand;
import org.eclipse.ptp.debug.external.core.commands.GetStackInfoDepthCommand;
import org.eclipse.ptp.debug.external.core.commands.GoCommand;
import org.eclipse.ptp.debug.external.core.commands.HaltCommand;
import org.eclipse.ptp.debug.external.core.commands.StepFinishCommand;
import org.eclipse.ptp.debug.external.core.commands.StepIntoCommand;
import org.eclipse.ptp.debug.external.core.commands.StepOverCommand;
import org.eclipse.ptp.debug.external.core.commands.TerminateCommand;

/**
 * @author Clement chu
 *
 */
public class Session implements IPCDISession, IPCDISessionObject {
	public final static Target[] EMPTY_TARGETS = {};
	Properties props;
	ProcessManager processManager;
	EventManager eventManager;
	BreakpointManager breakpointManager;
	ExpressionManager expressionManager;
	VariableManager variableManager;
	SourceManager sourceManager;
	MemoryManager memoryManager;
	SignalManager signalManager;
	IPCDISessionConfiguration configuration;
	IAbstractDebugger debugger = null;
	IPJob job = null;
	IPLaunch launch = null;
	IBinaryObject file;
	int no_of_process = 0;
	
	public Session(IAbstractDebugger debugger, IPJob job, int jobSize, IPLaunch launch, IBinaryObject file) throws CoreException {
		this.debugger = debugger;
		this.job = job;
		this.launch = launch;
		this.file = file;
		this.no_of_process = jobSize;
		commonSetup();
		//job.setAttribute(PreferenceConstants.JOB_DEBUG_SESSION, this);
	}
	private void commonSetup() {
		props = new Properties();
		setConfiguration(new SessionConfiguration(this));
		processManager = new ProcessManager(this);
		breakpointManager = new BreakpointManager(this);
		eventManager = new EventManager(this);
		expressionManager = new ExpressionManager(this);
		variableManager = new VariableManager(this);
		sourceManager = new SourceManager(this);
		memoryManager = new MemoryManager(this);
		signalManager = new SignalManager(this);
		//add observer
		this.debugger.addDebuggerObserver(eventManager);
	}
	
	public void shutdown() {
		try {
			debugger.exit();
		} catch (CoreException e) {
			//e.printStackTrace();
		}
		//DebugPlugin.getDefault().getLaunchManager().removeLaunch(launch);
		variableManager.shutdown();
		expressionManager.shutdown();
		breakpointManager.shutdown();
		eventManager.shutdown();
		sourceManager.shutdown();
		processManager.shutdown();
		memoryManager.shutdown();
		signalManager.shutdown();
	}
	public IPLaunch getLaunch() {
		return launch;
	}
	public IAbstractDebugger getDebugger() {
		return debugger;
	}
	public IPJob getJob() {
		return job;
	}
	public IBinaryObject getBinaryFile() {
		return file;
	}
	public void start(IProgressMonitor monitor) throws CoreException {
		IWorkspaceRunnable r = new IWorkspaceRunnable() {
			public void run(IProgressMonitor m) throws CoreException {
				boolean stopInMain = getLaunch().getLaunchConfiguration().getAttribute(IPTPLaunchConfigurationConstants.ATTR_STOP_IN_MAIN, false);
				m.subTask("Initializing breakpoints...");
				breakpointManager.setInitialBreakpoints();
				if (stopInMain) {
					breakpointManager.setInternalTemporaryBreakpoint(createBitList(), breakpointManager.createFunctionLocation("", "main"));
				}
				m.worked(5);
				if (m.isCanceled()) {
					throw new CoreException(Status.CANCEL_STATUS);
				}
				try {
					resume(createBitList());
					m.worked(5);
				} catch (PCDIException e) {
					throw new CoreException(new Status(IStatus.ERROR, PTPDebugExternalPlugin.getUniqueIdentifier(), IStatus.ERROR, e.getMessage(), null));			
				} finally {
					m.done();
					//PTPDebugCorePlugin.getDebugModel().fireSessionEvent(getJob(), Session.this);
				}
			}
		};
		ResourcesPlugin.getWorkspace().run(r, monitor);
	}	
	
	public void registerTargets(BitList tasks, boolean refresh) {
		registerTargets(tasks, refresh, false);
	}
	public void registerTargets(BitList tasks, boolean refresh, boolean resumeTarget) {
		IPCDITarget[] targets = processManager.addTargets(tasks);
		PTPDebugCorePlugin.getDebugModel().addNewDebugTargets(launch, tasks, targets, file, resumeTarget, refresh);
	}
	public void unregisterTargets(BitList tasks, boolean refresh) {
		processManager.removeTargets(tasks);
		PTPDebugCorePlugin.getDebugModel().removeDebugTarget(launch, tasks, refresh);
	}
	public String getAttribute(String key) {
		return props.getProperty(key);
	}
	public ProcessManager getProcessManager() {
		return processManager;
	}
	public IPCDIBreakpointManager getBreakpointManager() {
		return breakpointManager;
	}
	public IPCDIEventManager getEventManager() {
		return eventManager;
	}
	public ExpressionManager getExpressionManager() {
		return expressionManager;
	}
	public VariableManager getVariableManager() {
		return variableManager;
	}
	public SourceManager getSourceManager() {
		return sourceManager;
	}
	public MemoryManager getMemoryManager() {
		return memoryManager;
	}
	public SignalManager getSignalManager() {
		return signalManager;
	}
	public IPCDITarget[] getTargets() {
		return getProcessManager().getCDITargets();
	}
	public BitList getRegisteredTargets() {
		return getProcessManager().getRegisteredTargets();
	}
	public IPCDITarget getTarget(int target_id) {
		return getProcessManager().getTarget(target_id);
	}
	public void setAttribute(String key, String value) {
		props.setProperty(key, value);
	}
	public IPCDISessionConfiguration getConfiguration() {
		return configuration;
	}
	public void setConfiguration(IPCDISessionConfiguration conf) {
		configuration = conf;
	}
	public IPCDISession getSession() {
		return this;
	}
	public Process getSessionProcess() throws PCDIException {
		return null;
	}
	public BitList createEmptyBitList() {
		return new BitList(getTotalProcesses());
	}
	public BitList createBitList() {
		BitList tasks = createEmptyBitList();
		tasks.set(0, getTotalProcesses());
		return tasks;
	}
	public BitList createBitList(int index) {
		BitList tasks = createEmptyBitList();
		tasks.set(index);
		return tasks;
	}
	public int getTotalProcesses() {
		return no_of_process;
	}

	public void terminate() throws PCDIException {
		stop(createBitList());
	}
	public void stop(BitList tasks) throws PCDIException {
		getDebugger().postCommand(new TerminateCommand(tasks));
	}
	public void resume(BitList tasks) throws PCDIException {
		getDebugger().postCommand(new GoCommand(tasks));
	}
	public void suspend(BitList tasks) throws PCDIException {
		getDebugger().postCommand(new HaltCommand(tasks));
	}
	public void steppingInto(BitList tasks) throws PCDIException {
		getDebugger().postCommand(new StepIntoCommand(tasks));
	}
	public void steppingOver(BitList tasks) throws PCDIException {
		getDebugger().postCommand(new StepOverCommand(tasks));
	}
	public void steppingReturn(BitList tasks) throws PCDIException {
		getDebugger().postCommand(new StepFinishCommand(tasks));
	}
	public ICommandResult getExpressionValue(BitList tasks, String variable) throws PCDIException {
		GetAIFCommand command = new GetAIFCommand(tasks, variable);
		getDebugger().postCommand(command);
		return command.getAIF();
	}
	public BitList[] getStepReturnTasks(BitList tasks) throws PCDIException {
		GetStackInfoDepthCommand command = new GetStackInfoDepthCommand(tasks);
		getDebugger().postCommand(command);
		ICommandResult result = command.getDepths();
		Object[] objs = result.getResultsArray();
		BitList[] bits = result.getTasksArray();
		BitList addTasks = null;
		BitList delTasks = null;
		for (int i=0; i<bits.length; i++) {
			if (((Integer)objs[i]).intValue() > 1) {
				if (addTasks == null) {
					addTasks = bits[i].copy();
				}
				else {
					addTasks.or(bits[i]);
				}
			}
			else {
				if (delTasks == null) {
					delTasks = bits[i].copy();
				}
				else {
					delTasks.or(bits[i]);
				}
			}
		}
		return new BitList[] { addTasks, delTasks };
	}
}