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

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.ISourceLocator;
import org.eclipse.debug.core.model.IStackFrame;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.core.sourcelookup.containers.LocalFileStorage;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.sourcelookup.ISourceLookupResult;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.source.IAnnotationModel;
import org.eclipse.ptp.core.elements.IPJob;
import org.eclipse.ptp.core.resources.FileStorage;
import org.eclipse.ptp.debug.core.IPDebugEventListener;
import org.eclipse.ptp.debug.core.IPSession;
import org.eclipse.ptp.debug.core.PTPDebugCorePlugin;
import org.eclipse.ptp.debug.core.TaskSet;
import org.eclipse.ptp.debug.core.event.IPDebugEvent;
import org.eclipse.ptp.debug.core.event.IPDebugInfo;
import org.eclipse.ptp.debug.core.event.IPDebugSuspendInfo;
import org.eclipse.ptp.debug.core.model.IPDebugTarget;
import org.eclipse.ptp.debug.core.model.IPStackFrame;
import org.eclipse.ptp.debug.core.model.IPThread;
import org.eclipse.ptp.debug.core.pdi.PDIException;
import org.eclipse.ptp.debug.core.pdi.request.IPDIListStackFramesRequest;
import org.eclipse.ptp.debug.core.sourcelookup.PSourceLookupDirector;
import org.eclipse.ptp.debug.ui.IPTPDebugUIConstants;
import org.eclipse.ptp.debug.ui.PTPDebugUIPlugin;
import org.eclipse.ptp.debug.ui.UIDebugManager;
import org.eclipse.ptp.debug.ui.messages.Messages;
import org.eclipse.ptp.proxy.debug.client.ProxyDebugLocator;
import org.eclipse.ptp.proxy.debug.client.ProxyDebugStackFrame;
import org.eclipse.ptp.ui.IElementManager;
import org.eclipse.ptp.ui.listeners.IJobChangedListener;
import org.eclipse.ptp.ui.model.IElementHandler;
import org.eclipse.ptp.ui.model.IElementSet;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IStorageEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.progress.UIJob;
import org.eclipse.ui.progress.WorkbenchJob;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;

/*
 * @author Clement chu
 * 
 */
public class PAnnotationManager implements IJobChangedListener, IPDebugEventListener {
	private static PAnnotationManager instance = null;
	private final Object LOCK = new Object();
	protected Map<String, AnnotationGroup> annotationMap = Collections.synchronizedMap(new HashMap<String, AnnotationGroup>());
	protected UIDebugManager uiDebugManager = null;

	/* Constructor
	 * @param uiDebugManager
	 */
	public PAnnotationManager(UIDebugManager uiDebugManager) {
		this.uiDebugManager = uiDebugManager;
		// make sure every time created the same object reference
		if (instance == null) {
			uiDebugManager.addJobChangedListener(this);
			PTPDebugCorePlugin.getDefault().addDebugEventListener(this);
			instance = this;
		}
	}
	
	/* Get instance of PAnnotationManager
	 * @return
	 */
	public static PAnnotationManager getDefault() {
		if (instance == null)
			instance = new PAnnotationManager(PTPDebugUIPlugin.getUIDebugManager());
		return instance;
	}
	
	/* Clean all settings and listeners
	 * 
	 */
	public void shutdown() {
		clearAllAnnotations();
		PTPDebugCorePlugin.getDefault().removeDebugEventListener(this);
		uiDebugManager.removeJobChangedListener(this);
		annotationMap = null;
	}
	
	/* Clean all stored annotations
	 * 
	 */
	protected void clearAllAnnotations() {
		synchronized (LOCK) {
			for (Iterator<AnnotationGroup> i = annotationMap.values().iterator(); i.hasNext();) {
				i.next().removeAnnotations();
			}
			annotationMap.clear();
		}
	}
	
	/* Remove annotation group by given job
	 * @param job_id job ID
	 */
	protected void removeAnnotationGroup(String job_id) {
		synchronized (LOCK) {
			AnnotationGroup annotationGroup = (AnnotationGroup) annotationMap.remove(job_id);
			if (annotationGroup != null) {
				annotationGroup.removeAnnotations();
			}
		}
	}
	
	/* Add annotation to given job
	 * @param job_id Job ID
	 * @param annotationGroup
	 */
	protected void putAnnotationGroup(String job_id, AnnotationGroup annotationGroup) {
		synchronized (LOCK) {
			annotationMap.put(job_id, annotationGroup);
		}
	}
	
	/* Get annotation by given hob ID
	 * @param job_id job ID
	 * @return
	 */
	protected AnnotationGroup getAnnotationGroup(String job_id) {
		synchronized (LOCK) {
			return (AnnotationGroup) annotationMap.get(job_id);
		}
	}

	/* Get editor and open editor if it is not opened or focus on it if it is already opened
	 * @param page
	 * @param input
	 * @param id
	 * @return
	 */
	protected IEditorPart openEditor(final IWorkbenchPage page, final IEditorInput input, final String id) {
		final IEditorPart[] editor = new IEditorPart[] { null };
		Runnable r = new Runnable() {
			public void run() {
				try {
					editor[0] = page.openEditor(input, id, false);
				} catch (PartInitException e) {
					PTPDebugUIPlugin.errorDialog(PTPDebugUIPlugin.getActiveWorkbenchShell(), Messages.PAnnotationManager_0, Messages.PAnnotationManager_1, e);
				}
			}
		};
		BusyIndicator.showWhile(Display.getDefault(), r);
		return editor[0];
	}
	
	/* Get editor part
	 * @param file
	 * @return
	 */
	protected IEditorPart getEditorPart(final IFile file) {
		final IEditorPart[] editor = new IEditorPart[] { null };
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				IWorkbenchPage page = PTPDebugUIPlugin.getActiveWorkbenchWindow().getActivePage();
				IEditorPart editorPart = page.getActiveEditor();
				if (editorPart != null) {
					IEditorInput editorInput = editorPart.getEditorInput();
					if (editorInput instanceof IFileEditorInput) {
						if (((IFileEditorInput) editorInput).getFile().equals(file)) {
							page.bringToTop(editorPart);
							editor[0] = editorPart;
							return;
						}
					}
				}
				if (editor[0] == null) {
					for (IEditorReference refs : page.getEditorReferences()) {
						IEditorPart refEditor = refs.getEditor(false);
						if (refEditor == null)
							continue;
						IEditorInput editorInput = refEditor.getEditorInput();
						if (editorInput instanceof IFileEditorInput) {
							if (((IFileEditorInput) editorInput).getFile().equals(file)) {
								page.bringToTop(refEditor);
								editor[0] = refEditor;
								return;
							}
						}
					}
				}
				try {
					editor[0] = page.openEditor(PDebugUIUtils.getEditorInput(file), PDebugUIUtils.getEditorId(file), false);
				} catch (PartInitException e) {
					//PTPDebugUIPlugin.errorDialog(PTPDebugUIPlugin.getActiveWorkbenchShell(), "Error", "Cannot open editor", e);
				}
			}
		});
		return editor[0];
	}
	
	protected void displaySource(final ISourceLookupResult result) {
		UIJob uiJob = new UIJob(Messages.PAnnotationManager_2) {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				IWorkbenchPage page = PTPDebugUIPlugin.getActiveWorkbenchWindow().getActivePage();
				if (!monitor.isCanceled() && result != null && page != null) {
					DebugUITools.displaySource(result, page);
				}
				return Status.OK_STATUS;
			}
		};
		uiJob.schedule();
	}
	
	/* Find file
	 * @param fileName
	 * @return
	 */
	protected IFile findFile(String filename) {
		return findFile(new Path(filename));
	}
	
	protected IFile findFile(IPath location) {
		IPath normalized = FileBuffers.normalizeLocation(location);
		if (normalized.segmentCount() >= 2) {
			return ResourcesPlugin.getWorkspace().getRoot().getFile(normalized);
		}
		return null;
	}
	
	/* Get text editor
	 * @param editorPart
	 * @return
	 */
	protected ITextEditor getTextEditor(IEditorPart editorPart) {
		if (editorPart instanceof ITextEditor) {
			return (ITextEditor) editorPart;
		}
		return (ITextEditor) editorPart.getAdapter(ITextEditor.class);
	}
	
	/* Get file
	 * @param editorInput
	 * @return
	 */
	protected IFile getFile(IEditorInput editorInput) {
		if (editorInput instanceof IFileEditorInput)
			return ((IFileEditorInput) editorInput).getFile();
		if (editorInput instanceof IStorageEditorInput) {
			try {
				return findFile(((IStorageEditorInput)editorInput).getStorage().getFullPath());
			} catch (CoreException e) {
				return null;
			}
		}
		if (editorInput instanceof IStorage) {
			return findFile(((IStorage)editorInput).getName());
		}
		return null;
	}
	
	/* Create position in the source file
	 * @param lineNumber
	 * @param doc
	 * @return
	 */
	protected Position createPosition(int lineNumber, IDocument doc) {
		if (doc == null)
			return null;
		try {
			IRegion region = doc.getLineInformation(lineNumber - 1);
			int charStart = region.getOffset();
			int length = region.getLength();
			if (charStart < 0)
				return null;
			return new Position(charStart, length);
		} catch (BadLocationException ble) {
			return null;
		}
	}
	
	/* Get tasks from debug target
	 * @param debugTarget
	 * @return
	 */
	protected TaskSet getTasks(IDebugTarget debugTarget) {
		if (debugTarget instanceof IPDebugTarget) {
			return ((IPDebugTarget) debugTarget).getTasks();
		}
		return null;
	}
	
	/* Get tasks from thread
	 * @param thread
	 * @return
	 */
	protected TaskSet getTasks(IThread thread) {
		return getTasks(thread.getDebugTarget());
	}
	
	/* Is given type register type
	 * @param type
	 * @return
	 */
	protected boolean isRegisterType(String type) {
		return (type.equals(IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_CURRENT) || type.equals(IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_SECONDARY));
	}
	
	/* Focus to annotation in source editor
	 * @param editorPart
	 * @param stackFrame
	 * @throws CoreException
	 */
	protected void focusAnnotation(IEditorPart editorPart, IStackFrame stackFrame) throws CoreException {
		ITextEditor textEditor = getTextEditor(editorPart);
		int charStart = stackFrame.getCharStart();
		if (charStart > 0) {
			textEditor.selectAndReveal(charStart, 0);
			return;
		}
		int lineNumber = stackFrame.getLineNumber();
		lineNumber--;
		IRegion region= getLineInformation(textEditor, lineNumber);
		if (region != null) {
			textEditor.selectAndReveal(region.getOffset(), 0);
		}
	}
	
	/* Get line region in source editor
	 * @param editor
	 * @param lineNumber
	 * @return
	 */
	protected IRegion getLineInformation(ITextEditor editor, int lineNumber) {
		IDocumentProvider provider= editor.getDocumentProvider();
		IEditorInput input= editor.getEditorInput();
		try {
			provider.connect(input);
		} catch (CoreException e) {
			return null;
		}
		try {
			IDocument document= provider.getDocument(input);
			if (document != null)
				return document.getLineInformation(lineNumber);
		} catch (BadLocationException e) {
		} finally {
			provider.disconnect(input);
		}
		return null;
	}
	
	// called by debug view - PDebugModelPresentation
	/* Add annotation called from Debug View
	 * @param editorPart
	 * @param stackFrame
	 * @throws CoreException
	 */
	public void addAnnotation(IEditorPart editorPart, IPStackFrame stackFrame) throws CoreException {
		IPStackFrame selectedFrame = stackFrame;
		
		TaskSet tasks = getTasks(stackFrame.getDebugTarget());
		if (tasks == null) {
			throw new CoreException(Status.CANCEL_STATUS);
		}
		
		ITextEditor textEditor = getTextEditor(editorPart);
		if (textEditor == null) {
			throw new CoreException(Status.CANCEL_STATUS);
		}
		
		IFile file = getFile(textEditor.getEditorInput());
		if (file == null) {
			throw new CoreException(Status.CANCEL_STATUS);
		}
		
		//try to find the stack frame with line number
		if (selectedFrame.getLineNumber() == 0) {
			IStackFrame[] frames = selectedFrame.getThread().getStackFrames();
			for (IStackFrame frame : frames) {
				if (frame.getLineNumber() > 0) {
					selectedFrame = (IPStackFrame)frame;
					break;
				}
			}
		}
		
		if (selectedFrame.getLineNumber() > 0) {
			String job_id = uiDebugManager.getCurrentJobId();
			synchronized (LOCK) {
				AnnotationGroup annotationGroup = getAnnotationGroup(job_id);
				if (annotationGroup == null) {
					annotationGroup = new AnnotationGroup();
					putAnnotationGroup(job_id, annotationGroup);
				}
				removeAnnotation(annotationGroup, tasks);
				addAnnotation(annotationGroup, textEditor, file, selectedFrame.getLineNumber(), tasks, (selectedFrame.getLevel() > 1) ? IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_SECONDARY : IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_CURRENT);
			}
		}
	}
	
	/**
	 * Get the source locator for this debug launch
	 * 
	 * @param job_id id of debug job
	 * @return source locator or null if not found
	 */
	private PSourceLookupDirector getSourceLocator(String job_id) {
		IPSession session = uiDebugManager.getDebugSession(job_id);
		if (session != null) {
			ISourceLocator locator = session.getLaunch().getSourceLocator();
			if (locator instanceof PSourceLookupDirector) {
				return (PSourceLookupDirector)locator;
			}
		}
		return null;
	}
	
	private IPath getFilePath(String job_id, String filename) {
		PSourceLookupDirector locator = getSourceLocator(job_id);
		if (locator != null) {
			Object object = locator.getSourceElement(filename);
			if (object instanceof IFile) {
				return ((IFile)object).getFullPath();
			}
			if (object instanceof LocalFileStorage) {
				return ((LocalFileStorage)object).getFullPath();
			}
			if (object instanceof FileStorage) {
				return ((FileStorage)object).getFullPath();
			}
		}
		return new Path(filename);
	}
	
	// called by event
	/*
	 * Add annotation called from debug event
	 */
	protected void addUnregisterAnnotation(String job_id, int level, String filename, int lineNumber, TaskSet tasks) throws CoreException {
		if (tasks.isEmpty())
			return;

		IFile file = findFile(getFilePath(job_id, filename));
		if (file == null)
			throw new CoreException(Status.CANCEL_STATUS);

		IEditorPart editorPart = getEditorPart(file);
		if (editorPart == null)
			throw new CoreException(Status.CANCEL_STATUS);
		ITextEditor textEditor = getTextEditor(editorPart);
		if (textEditor == null)
			throw new CoreException(Status.CANCEL_STATUS);
		
		synchronized (LOCK) {
			AnnotationGroup annotationGroup = getAnnotationGroup(job_id);
			if (annotationGroup == null) {
				annotationGroup = new AnnotationGroup();
				putAnnotationGroup(job_id, annotationGroup);
			}
			addAnnotation(annotationGroup, textEditor, file, lineNumber, tasks, ((level > 1)?IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT:((containsCurrentSet(tasks)) ? IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT : IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT)));				
		}
	}
	
	/**
	 * Add annotation given filename and line number
	 * 
	 * @param job_id
	 * @param level
	 * @param filename
	 * @param lineNumber
	 * @param rTasks
	 * @param uTasks
	 * @throws CoreException
	 */
	protected void addAnnotation(String job_id, int level, String filename, int lineNumber, TaskSet rTasks, TaskSet uTasks) throws CoreException {
		IFile file = findFile(getFilePath(job_id, filename));
		if (file == null) {
			throw new CoreException(Status.CANCEL_STATUS);
		}

		IEditorPart editorPart = getEditorPart(file);
		if (editorPart == null) {
			throw new CoreException(Status.CANCEL_STATUS);
		}
		
		ITextEditor textEditor = getTextEditor(editorPart);
		if (textEditor == null) {
			throw new CoreException(Status.CANCEL_STATUS);
		}
		
		synchronized (LOCK) {
			AnnotationGroup annotationGroup = getAnnotationGroup(job_id);
			if (annotationGroup == null) {
				annotationGroup = new AnnotationGroup();
				putAnnotationGroup(job_id, annotationGroup);
			}
			addAnnotation(annotationGroup, textEditor, file, lineNumber, rTasks, ((level > 1)?IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_SECONDARY: IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_CURRENT));				
			addAnnotation(annotationGroup, textEditor, file, lineNumber, uTasks, ((level > 1)?IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT:((containsCurrentSet(uTasks)) ? IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT : IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT)));				
		}
	}
	
	/* Is given tasks in the current set
	 * @param aTasks
	 * @return
	 */
	protected boolean containsCurrentSet(TaskSet aTasks) {
		String set_id = uiDebugManager.getCurrentSetId();
		if (set_id.equals(IElementHandler.SET_ROOT_ID))
			return true;
		try {
			TaskSet tasks = uiDebugManager.getTasks(set_id);
			return (tasks != null && tasks.intersects(aTasks));
		}
		catch (CoreException e) {
			return false;
		}
	}
	
	// generic
	/* Add annotation
	 * @param annotationGroup
	 * @param textEditor
	 * @param file
	 * @param lineNumber
	 * @param tasks
	 * @param type
	 * @throws CoreException
	 */
	protected void addAnnotation(AnnotationGroup annotationGroup, final ITextEditor textEditor, final IFile file, final int lineNumber, final TaskSet tasks, final String type) throws CoreException {
		if (!tasks.isEmpty()) {
			IDocumentProvider docProvider = textEditor.getDocumentProvider();
			IAnnotationModel annotationModel = docProvider.getAnnotationModel(textEditor.getEditorInput());
			if (annotationModel == null)
				throw new CoreException(Status.CANCEL_STATUS);
			final Position position = createPosition(lineNumber, docProvider.getDocument(textEditor.getEditorInput()));
			if (position == null)
				throw new CoreException(Status.CANCEL_STATUS);

			synchronized (LOCK) {
				PInstructionPointerAnnotation2 annotation = findAnnotation(annotationGroup, position, type);
				if (annotation == null) {
					annotation = new PInstructionPointerAnnotation2(file, type, position, annotationModel);
					annotationGroup.addAnnotation(annotation);
				}
				annotation.addTasks(tasks);
				annotation.setMessage(isRegisterType(type));
			}
			Display.getDefault().asyncExec(new Runnable() {
				public void run() {
					textEditor.selectAndReveal(position.getOffset(), 0);
				}
			});
		}
	}
	
	/* Find annotation
	 * @param annotationGroup
	 * @param position
	 * @param type
	 * @return
	 */
	protected PInstructionPointerAnnotation2 findAnnotation(AnnotationGroup annotationGroup, Position position, String type) {
		synchronized (LOCK) {
			for (PInstructionPointerAnnotation2 annotation : annotationGroup.getAnnotations()) {
				if (annotation.getPosition().equals(position)) {
					if (annotation.getType().equals(type)) {
						return annotation;
					}
				}
			}
			return null;
		}
	}
	
	// called by debug view
	/* Remove annotation called from Debug View
	 * @param editorPart
	 * @param thread
	 * @throws CoreException
	 */
	protected void removeAnnotation(IEditorPart editorPart, IPThread thread) throws CoreException {
		removeAnnotation(uiDebugManager.getCurrentJobId(), getTasks(thread));
	}
	
	// called by event
	/* Remove annotation called from debug event
	 * @param job_id
	 * @param tasks
	 * @throws CoreException
	 */
	protected void removeAnnotation(String job_id, TaskSet tasks) throws CoreException {
		if (tasks == null || tasks.isEmpty())
			throw new CoreException(Status.CANCEL_STATUS);
		synchronized (LOCK) {
			AnnotationGroup annotationGroup = getAnnotationGroup(job_id);
			if (annotationGroup != null) {
				removeAnnotation(annotationGroup, tasks);
				if (annotationGroup.isEmpty())
					removeAnnotationGroup(job_id);
			}
		}
	}
	
	// generic
	/* Remove annotation
	 * @param annotationGroup
	 * @param tasks
	 * @throws CoreException
	 */
	protected void removeAnnotation(AnnotationGroup annotationGroup, TaskSet tasks) throws CoreException {
		synchronized (LOCK) {
			List<PInstructionPointerAnnotation2> removedList = new ArrayList<PInstructionPointerAnnotation2>(0);
			for (PInstructionPointerAnnotation2 annotation : annotationGroup.getAnnotations()) {
				annotation.removeTasks(tasks);
				if (annotation.isEmpty()) {
					annotation.removeAnnotation();
					removedList.add(annotation);
				} else {
					annotation.setMessage(isRegisterType(annotation.getType()));
				}
			}
			annotationGroup.removeAnnotations(removedList);
		}
	}
	
	/* Get iterator of stored annotations
	 * @param annotationGroup
	 * @param type
	 * @return
	 */
	public PInstructionPointerAnnotation2[] findAnnotations(AnnotationGroup annotationGroup, String type) {
		synchronized (LOCK) {
			List<PInstructionPointerAnnotation2> foundAnnotations = new ArrayList<PInstructionPointerAnnotation2>();
			for (PInstructionPointerAnnotation2 annotation : annotationGroup.getAnnotations()) {
				if (annotation.getType().equals(type)) {
					foundAnnotations.add(annotation);
				}
			}
			return foundAnnotations.toArray(new PInstructionPointerAnnotation2[0]);
		}
	}
	
	protected PInstructionPointerAnnotation2[] findAnnotations(AnnotationGroup annotationGroup, TaskSet tasks) {
		synchronized (LOCK) {
			List<PInstructionPointerAnnotation2> foundAnnotations = new ArrayList<PInstructionPointerAnnotation2>();
			if (tasks.isEmpty())
				return new PInstructionPointerAnnotation2[0];

			for (PInstructionPointerAnnotation2 annotation : annotationGroup.getAnnotations()) {
				if (!annotation.isMarkDeleted() && annotation.contains(tasks)) {
					if (!foundAnnotations.contains(annotation))
						foundAnnotations.add(annotation);
				}
			}
			return foundAnnotations.toArray(new PInstructionPointerAnnotation2[0]);
		}
	}
	
	/* Find other annotation
	 * @param annotationGroup
	 * @param position
	 * @param isRegister
	 * @return
	 */
	protected PInstructionPointerAnnotation2 findOtherTypeAnnotation(AnnotationGroup annotationGroup, Position position, boolean isRegister) {
		synchronized (LOCK) {
			for (PInstructionPointerAnnotation2 annotation : annotationGroup.getAnnotations()) {
				if (annotation.getPosition().equals(position)) {
					String annotationType = annotation.getType();
					if (isRegister) {
						if (annotationType.equals(IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT) || annotationType.equals(IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT))
							return annotation;
					} else {
						if (annotationType.equals(IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_CURRENT) || annotationType.equals(IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_SECONDARY))
							return annotation;
					}
				}
			}
			return null;
		}
	}
	
	/* Change annotation type
	 * @param annotation
	 * @param type
	 */
	protected void changeAnnotationType(PInstructionPointerAnnotation2 annotation, String type) {
		if (!annotation.getType().equals(type)) {			
			annotation.setType(type);
		}
	}
	
	protected void register(String job_id, TaskSet tasks) {
		synchronized (LOCK) {
			AnnotationGroup annotationGroup = getAnnotationGroup(job_id);
			if (annotationGroup != null) {
				for (PInstructionPointerAnnotation2 annotation : findAnnotations(annotationGroup, tasks)) {
					TaskSet cpTasks = tasks.copy();
					cpTasks.and(annotation.getTasks());
					if (cpTasks.isEmpty())
						continue;
					
					updateExistedAnnotation(annotationGroup, annotation, cpTasks, false);
					/*
					boolean isRegister = isRegisterType(annotation.getType());
					if (!isRegister)// unregister annotation
						updateExistedAnnotation(annotationGroup, annotation, cpTasks, isRegister);
					*/
				}
			}
		}
	}
	
	protected void unregister(String job_id, TaskSet tasks) {
		synchronized (LOCK) {
			AnnotationGroup annotationGroup = getAnnotationGroup(job_id);
			if (annotationGroup != null) {
				for (PInstructionPointerAnnotation2 annotation : findAnnotations(annotationGroup, tasks)) {
					TaskSet cpTasks = tasks.copy();
					cpTasks.and(annotation.getTasks());
					if (cpTasks.isEmpty())
						continue;

					updateExistedAnnotation(annotationGroup, annotation, cpTasks, true);
					/*
					boolean isRegister = isRegisterType(annotation.getType());
					if (isRegister)// register annotation
						updateExistedAnnotation(annotationGroup, annotation, cpTasks, isRegister);
					*/
				}
			}
		}
	}
	
	/* Remove tasks from existed annotation
	 * @param annotationGroup
	 * @param annotation
	 * @param tasks Tasks being removed
	 * @param isRegister
	 * @throws CoreException
	 */
	protected void updateExistedAnnotation(AnnotationGroup annotationGroup, PInstructionPointerAnnotation2 annotation, TaskSet tasks, boolean isRegister) {
		synchronized (LOCK) {
			IResource file = annotation.getMakerResource();
			Position position = annotation.getPosition();
			annotation.removeTasks(tasks);
			if (annotation.isEmpty()) {
				annotation.removeAnnotation();
				annotationGroup.removeAnnotation(annotation);
			}
			else {
				annotation.setMessage(isRegister);
			}
	
			PInstructionPointerAnnotation2 oAnnotation = findOtherTypeAnnotation(annotationGroup, position, isRegister);
			if (oAnnotation != null) {
				oAnnotation.addTasks(tasks);
				oAnnotation.setMessage(!isRegister);
			}
			else {
				//String type = isRegister ? ((containsCurrentSet(tasks) ? IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT : IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT)) : IPTPDebugUIConstants.REG_ANN_INSTR_POINTER_CURRENT;
				String type = IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT;
				oAnnotation = new PInstructionPointerAnnotation2(file, type, position, annotation.getAnnotationModel());
				annotationGroup.addAnnotation(oAnnotation);
				oAnnotation.addTasks(tasks);
				oAnnotation.setMessage(!isRegister);
			}
		}
	}
	
	/***************************************************************************************************************************************************************************************************
	 * Set Change Event
	 **************************************************************************************************************************************************************************************************/
	/* Update annotation
	 * @param currentSet current set
	 * @param preSet previous set
	 * @throws CoreException
	 */
	public void updateAnnotation(final IElementSet currentSet, final IElementSet preSet) {
		WorkbenchJob uiJob = new WorkbenchJob(Messages.PAnnotationManager_3) {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				AnnotationGroup annotationGroup = getAnnotationGroup(uiDebugManager.getCurrentJobId());
				if (annotationGroup != null) {
					try {
						TaskSet tasks = uiDebugManager.getTasks(currentSet.getID());
						synchronized (LOCK) {
							for (PInstructionPointerAnnotation2 annotation : annotationGroup.getAnnotations()) {
								// change icon for unregistered processes only if the set is changed
								if (!isRegisterType(annotation.getType())) {
									// if all the tasks in current is not match the unregistered tasks, display SET_ANN
									// simply only display SET_ANN when the current set only contain registered tasks
									if (currentSet.isRootSet())
										changeAnnotationType(annotation, IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT);
									else
										changeAnnotationType(annotation, annotation.contains(tasks) ? IPTPDebugUIConstants.CURSET_ANN_INSTR_POINTER_CURRENT : IPTPDebugUIConstants.SET_ANN_INSTR_POINTER_CURRENT);
								}
							}
						}
					}
					catch (CoreException e) {
						return e.getStatus();
					}
				}
				return Status.OK_STATUS;
			}
		};
		uiJob.setSystem(true);
		uiJob.setPriority(Job.INTERACTIVE);
		uiJob.schedule();
	}
	
	/***************************************************************************************************************************************************************************************************
	 * Job Change Listener
	 **************************************************************************************************************************************************************************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.listeners.IJobChangedListener#jobChangedEvent(int, java.lang.String, java.lang.String)
	 */
	public void jobChangedEvent(final int type, final String cur_job_id, final String pre_job_id) {
		WorkbenchJob uiJob = new WorkbenchJob(Messages.PAnnotationManager_3) {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				doJobChangedEvent(type, cur_job_id, pre_job_id, monitor);
				monitor.done();
				return Status.OK_STATUS;
			}
		};
		uiJob.setSystem(true);
		uiJob.setPriority(Job.INTERACTIVE);
		uiJob.schedule();
	}
	
	private void doJobChangedEvent(int type, String cur_job_id, String pre_job_id, IProgressMonitor monitor) {
		if (type == IJobChangedListener.REMOVED || (pre_job_id != null && !pre_job_id.equals(IElementManager.EMPTY_ID))) {
			AnnotationGroup preAnnotationGroup = getAnnotationGroup(pre_job_id);
			if (preAnnotationGroup != null) {
				preAnnotationGroup.throwAllAnnotations();
			}
		}
		if (cur_job_id != null) {
			AnnotationGroup curAnnotationGroup = getAnnotationGroup(cur_job_id);
			if (curAnnotationGroup != null) {
				curAnnotationGroup.retrieveAllAnnontations();
			}
		}		
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.debug.core.IPDebugEventListener#handleDebugEvent(org.eclipse.ptp.debug.core.events.IPDebugEvent)
	 */
	public void handleDebugEvent(final IPDebugEvent event) {
		WorkbenchJob uiJob = new WorkbenchJob(Messages.PAnnotationManager_3) {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				doHandleDebugEvent(event, monitor);
				monitor.done();
				return Status.OK_STATUS;
			}
		};
		uiJob.setSystem(true);
		uiJob.setPriority(Job.INTERACTIVE);
		uiJob.schedule();
	}
	
	/**
	 * Process the debug event
	 * 
	 * @param event
	 * @param monitor
	 */
	private void doHandleDebugEvent(IPDebugEvent event, IProgressMonitor monitor) {
		IPDebugInfo info = event.getInfo();
		IPJob job = info.getJob();
		switch(event.getKind()) {
			case IPDebugEvent.CREATE:
				switch (event.getDetail()) {
				case IPDebugEvent.REGISTER:
					register(job.getID(), info.getAllTasks());
					break;
				case IPDebugEvent.BREAKPOINT:
					break;
				}
				break;
			case IPDebugEvent.TERMINATE:
				switch (event.getDetail()) {
				case IPDebugEvent.DEBUGGER:
					removeAnnotationGroup(job.getID());
					break;
				case IPDebugEvent.REGISTER:
					unregister(job.getID(), info.getAllTasks());
					break;
				case IPDebugEvent.BREAKPOINT:
					break;
				default:
					removeAnnotationAction(job, info.getAllTasks());
					break;
				}
				break;
			case IPDebugEvent.RESUME:
				removeAnnotationAction(job, info.getAllTasks());
				break;
			case IPDebugEvent.SUSPEND:
				IPDebugSuspendInfo susInfo = (IPDebugSuspendInfo)info;
				try {
					addAnnotation(job, susInfo);
				} catch (final CoreException e) {
					PTPDebugUIPlugin.getDisplay().asyncExec(new Runnable() {
						public void run() {
							PTPDebugUIPlugin.errorDialog(Messages.PAnnotationManager_0, e);
						}
					});
				}
				break;
			case IPDebugEvent.CHANGE:
				break;
			case IPDebugEvent.ERROR:
				//removeAnnotationAction(job, info.getAllTasks());
				break;
		}
	}
	
	/**
	 * Add annotation for a suspend event
	 * 
	 * @param job debug job
	 * @param info suspend event information
	 * @throws CoreException
	 */
	private void addAnnotation(IPJob job, IPDebugSuspendInfo info) throws CoreException {
		int line = info.getLineNumber();
		if (line == 0) {
			//FIXME: this method is only for unreg tasks, reg tasks depends on selection on stack frame on debug view
			addAnnotationWithSourceFound(job, info.getAllUnregisteredTasks(), info.getLevel()+1, info.getDepth());
		}
		else {
			addAnnotation(job.getID(), info.getLevel(), info.getFilename(), line, info.getAllRegisteredTasks(), info.getAllUnregisteredTasks());
		}
	}
	
	private void addAnnotationWithSourceFound(IPJob job, TaskSet tasks, int low, int high) throws CoreException {
		if (tasks.isEmpty())
			return;

		IPSession session = uiDebugManager.getDebugSession(job);
		if (session != null) {
			if (!session.isReady())
				return;
			
			IPDIListStackFramesRequest request = session.getPDISession().getRequestFactory().getListStackFramesRequest(session.getPDISession(), 
					tasks, low, high);
			try {
				session.getPDISession().getEventRequestManager().addEventRequest(request);
				Map<TaskSet, Object> map = request.getResultMap(tasks);
				for (Iterator<TaskSet> i = map.keySet().iterator(); i.hasNext();) {
					TaskSet sTasks = i.next();
					Object value = map.get(sTasks);
					if (value instanceof ProxyDebugStackFrame[]) {
						ProxyDebugStackFrame[] frames = (ProxyDebugStackFrame[])value;
						for (ProxyDebugStackFrame frame : frames) {
							ProxyDebugLocator locator = frame.getLocator();
							if (locator.getLineNumber() > 0) {
								addUnregisterAnnotation(job.getID(), frame.getLevel(), locator.getFile(), locator.getLineNumber(), sTasks);
								break;
							}
						}
					}
				}
			}
			catch (PDIException e) {
				//throw new CoreException(new Status(IStatus.ERROR, PTPDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, e.getMessage(), null));
			}
		}
	}
	
	private void removeAnnotationAction(IPJob job, TaskSet tasks) {
		try {
			removeAnnotation(job.getID(), tasks);
		}
		catch (final CoreException e) {
			PTPDebugUIPlugin.getDisplay().asyncExec(new Runnable() {
				public void run() {
					PTPDebugUIPlugin.errorDialog(Messages.PAnnotationManager_0, e);
				}
			});
		}
	}
}