package org.eclipse.mylar.viz.seesoft;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.eclipse.contribution.visualiser.VisualiserPlugin;

import org.eclipse.contribution.visualiser.core.ProviderManager;

import org.eclipse.contribution.visualiser.core.resources.VisualiserImages;

import org.eclipse.contribution.visualiser.interfaces.IContentProvider;

import org.eclipse.contribution.visualiser.interfaces.IGroup;

import org.eclipse.contribution.visualiser.interfaces.IMember;

import org.eclipse.contribution.visualiser.jdtImpl.JDTGroup;

import org.eclipse.contribution.visualiser.jdtImpl.JDTMember;

import org.eclipse.contribution.visualiser.utils.JDTUtils;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.mylar.core.IMylarContext;

import org.eclipse.mylar.core.IMylarContextListener;

import org.eclipse.mylar.core.IMylarElement;

import org.eclipse.mylar.core.MylarPlugin;

import org.eclipse.mylar.java.JavaStructureBridge;

/**

 * Provides interesting java packages and classes for display in the Visualiser view.

 * 

 * Note: This currently updates after the interest changes for any context node. 

 * If performance is a problem, this could be modified to only update when a 

 * landmark is added or removed. 

 * 

 * @author Wesley Coelho

 */

public class JavaContextContentProvider implements IContentProvider, IMylarContextListener {

	/** IGroups representing packages with interesting elements in them */

	protected List<JDTGroup> groups = new ArrayList<JDTGroup>();	

	/** True if there is currently an active context */

	protected boolean contextActive = false;

	/** True if the visualiser has set this provider active*/

	protected boolean viewActive = false;

	public void initialise(){

		MylarPlugin.getContextManager().addListener(this);

	}

	/**

	 * Returns all registered groups

	 * @see org.eclipse.contribution.visualiser.interfaces.IContentProvider#getAllGroups()

	 * @return List of IGroups

	 */

	public List getAllGroups() {

		buildModel();

		return groups;

	}

	public List getAllMembers(IGroup group) {

		return group.getMembers();

	}

	/**

	 * Returns the List of all IMembers in all registered groups

	 * Adapted from org.eclipse.contribution.visualiser.SimpleContentProvider

	 */

	public List getAllMembers() {

		List grps = getAllGroups();

		List<IMember> members = new ArrayList<IMember>();

		if (grps == null) return members;

		Iterator iter = grps.iterator();

		while (iter.hasNext()) {

			IGroup grp = (IGroup)iter.next();

			List membersInGroup = getAllMembers(grp);

			Iterator iter2 = membersInGroup.iterator();

			while (iter2.hasNext()) {

				IMember im = (IMember)iter2.next();

				members.add(im);

			}

		}

		return members;

	}

	/** 

	 * Constructs the model to be displayed in the visualiser by requesting

	 * the active context's interesting elements and converting them to the

	 * groups and members structure

	 */

	protected void buildModel(){

		try {

			if(!(ProviderManager.getContentProvider().equals(this))){

				return;

			}

			groups.clear();

			if (!contextActive || !viewActive){

				return;

			}

			List<IMylarElement> interestingNodes = MylarPlugin.getContextManager().getActiveContext().getInteresting();

			JavaStructureBridge jBridge = new JavaStructureBridge();

			for (int i = 0; i < interestingNodes.size(); i++){

				IMylarElement node = interestingNodes.get(i);

				if (node.getContentType().equals(JavaStructureBridge.CONTENT_TYPE)){

					String handleID = node.getHandleIdentifier();

					IJavaElement jElement = (IJavaElement) jBridge.getObjectForHandle(handleID);

					if (jElement.getElementType() == IJavaElement.TYPE){

						String typeName = jBridge.getName(jElement);

						if (typeName.equals("")){

							continue;

						}

						JDTMember javaType = new JDTMember(typeName, jElement);

						addTypeToGroups(javaType);

					}

				}

			}

		} catch (RuntimeException e) {

			MylarPlugin.fail(e, "Could not provide data for the visualiser", false);

		}

	}

	/**

	 * Adds the specified visualiser member to the group representing its package

	 * in the groups list. The package group is created as required.

	 */

	protected void addTypeToGroups(JDTMember javaType){

		IJavaElement packageElt = javaType.getResource().getParent();

		while (packageElt.getParent() != null){

			if (packageElt.getElementType() == IJavaElement.PACKAGE_FRAGMENT){

				break;

			}

			packageElt = packageElt.getParent();

		}

		if (packageElt.getElementType() != IJavaElement.PACKAGE_FRAGMENT){

			MylarPlugin.fail(new Exception("Could not find package for java element"), "Could not find package for java element", false);

			return;

		}

		ICompilationUnit compilationUnit = Util.getCompilationUnit(javaType.getResource());

		if (compilationUnit == null || !compilationUnit.exists()){

			return;

		}

		javaType.setSize(Util.getLength(compilationUnit));

		JDTGroup parentGroup = new JDTGroup(packageElt.getElementName());

		//Check for an existing group for this package

		for (int i = 0; i < groups.size(); i++){

			JDTGroup currGroup = groups.get(i);

			if (currGroup.getFullname().equals(parentGroup.getFullname())){

				parentGroup = currGroup;

				break;

			}

		}

		List<IMember> memberList = new ArrayList<IMember>();

		memberList.add(javaType);

		parentGroup.addMembers(memberList);

		if (!groups.contains(parentGroup)){

			groups.add(parentGroup);

		}

	}

	/**

	 * @see org.eclipse.contribution.visualiser.interfaces.IContentProvider#getMemberViewIcon()

	 */

	public ImageDescriptor getMemberViewIcon() {

		return VisualiserImages.CLASS_VIEW;

	}

	/**

	 * @see org.eclipse.contribution.visualiser.interfaces.IContentProvider#getGroupViewIcon()

	 */

	public ImageDescriptor getGroupViewIcon() {

		return VisualiserImages.PACKAGE_VIEW;

	}

	/**

	 * Process a mouse click on a member

	 * @see org.eclipse.contribution.visualiser.interfaces.IContentProvider#processMouseclick(IMember, boolean, int)

	 * Copied from JDTContentProvider

	 */

	public boolean processMouseclick(

		IMember member,

		boolean markupWasClicked,

		int buttonClicked) {

		if(buttonClicked != 1){

			return true;	

		}

		if(markupWasClicked) {

			return false;

		}

		if(member instanceof JDTMember) {

			IJavaElement jEl = ((JDTMember)member).getResource();

			if(jEl != null) {

				JDTUtils.openInEditor(jEl.getResource(), JDTUtils.getClassDeclLineNum(jEl));

			}

		}

		return false;

	}

	public String getEmptyMessage() {

		return "No active context to display.";

	}

	//Begin implementation of IMylarContextListener

	public void contextActivated(IMylarContext context) {

		contextActive = true;

		VisualiserPlugin.refresh();

	}

	public void contextDeactivated(IMylarContext context) {

		contextActive = false;

		VisualiserPlugin.refresh();

	}

	public void presentationSettingsChanging(UpdateKind kind) {

	}

	public void presentationSettingsChanged(UpdateKind kind) {

		if (kind == UpdateKind.HIGHLIGHTER){

			VisualiserPlugin.refresh();

		}

	}

	public void interestChanged(IMylarElement node) {

	}

	public void interestChanged(List<IMylarElement> nodes) {

		VisualiserPlugin.refresh();

	}

	public void nodeDeleted(IMylarElement node) {

		VisualiserPlugin.refresh();

	}

	public void landmarkAdded(IMylarElement node) {

		VisualiserPlugin.refresh();

	}

	public void landmarkRemoved(IMylarElement node) {

		VisualiserPlugin.refresh();

	}

	public void edgesChanged(IMylarElement node) {

	}

	public void activate() {

		viewActive = true;

	}

	public void deactivate() {

		viewActive = false;

	}

}

package org.eclipse.mylar.viz.seesoft;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.SortedSet;

import java.util.TreeSet;

import org.eclipse.contribution.visualiser.core.Stripe;

import org.eclipse.contribution.visualiser.interfaces.IGroup;

import org.eclipse.contribution.visualiser.interfaces.IMarkupKind;

import org.eclipse.contribution.visualiser.interfaces.IMarkupProvider;

import org.eclipse.contribution.visualiser.interfaces.IMember;

import org.eclipse.contribution.visualiser.jdtImpl.JDTMember;

import org.eclipse.contribution.visualiser.simpleImpl.SimpleMarkupKind;

import org.eclipse.contribution.visualiser.utils.JDTUtils;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.ISourceReference;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.mylar.core.IDegreeOfInterest;

import org.eclipse.mylar.core.IMylarElement;

import org.eclipse.mylar.core.MylarPlugin;

import org.eclipse.mylar.tasklist.ITask;

import org.eclipse.mylar.tasklist.MylarTasklistPlugin;

import org.eclipse.mylar.ui.internal.UiUtil;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.RGB;

/**

 * Provides horizontal stripes that represent interesting members

 * of a class in the visualiser view

 * 

 * @author Wesley Coelho

 */

public class JavaContextMarkupProvider implements IMarkupProvider {

	/**Assigned when there is no highlight color for a task or it is too light */

	public Color defaultStripeColor = new Color(null, new RGB(128,128,255));

	/**Holds all IMarkupKinds (for the visualiser menu) */

	SortedSet<IMarkupKind> markupKindSet = new TreeSet<IMarkupKind>();

	/**Contains the color assigned to a markupkind for a particular task*/

	protected Map<IMarkupKind, Color> kindToColorMap = new HashMap<IMarkupKind, Color>();

	/**Records colors that have been explicitly set in the visualiser menu so they are not overridden*/

	protected Map<IMarkupKind, Object> colorSetByVisualiserMap = new HashMap<IMarkupKind, Object>();

	public void initialise() {

	}

	/**

	 * Returns a list of Stripes representing the interesting

	 * declarations in the specified IMember where the IMember

	 * represents a Java class.

	 */

	public List getMemberMarkups(IMember member) {

		try {

			List<Stripe> stripeList = new ArrayList<Stripe>();

			IJavaElement classElt = (IJavaElement)((JDTMember)member).getResource();

			if (classElt instanceof IType){

				IJavaElement[] classMembers = ((IType)classElt).getChildren();

				for(int i = 0; i < classMembers.length; i++){

					Stripe memberStripe = makeStripeForJavaMember(classMembers[i]);

					if (memberStripe != null){

						stripeList.add(memberStripe);

					}

				}

			}

			return stripeList;

		} catch (JavaModelException e) {

			MylarPlugin.fail(e, "Could not produce markups for member", false);

			return new ArrayList<Stripe>();

		}

	}

	/**

	 * Produces a stripe for the given member with the offset set to

	 * the line where the member appears in the file and the 

	 * depth set to the number of lines in a method or 1 for fields.

	 * Returns null if the member was not interesting or if there 

	 * was a problem getting all the required information.

	 */

	protected Stripe makeStripeForJavaMember(IJavaElement member){

		try {

			IMylarElement memberMylarElement = MylarPlugin.getContextManager().getNode(member.getHandleIdentifier());

			if (memberMylarElement != null){

				IDegreeOfInterest degreeOfInterest = memberMylarElement.getDegreeOfInterest();

				if(!degreeOfInterest.isInteresting() && !degreeOfInterest.isLandmark()){

					return null;

				}

				//Set the depth of the stripe to the number of lines in the member

				Stripe stripe = new Stripe();

				int stripeDepth = 1;

				if (member instanceof IMethod){

					stripeDepth = Util.getLength((IMethod)member);

				}

				stripe.setDepth(stripeDepth);

				//Set the offset to the starting line of the member in the file

				int offset = 0;

				if (member instanceof ISourceReference){

					try {

						offset = JDTUtils.getLineNumber(Util.getCompilationUnit(member),  ((ISourceReference)member).getSourceRange().getOffset());

					} catch (JavaModelException e) {

						MylarPlugin.fail(e, "could not get member line number", false);

					}

				}

				stripe.setOffset(offset);

				//Set the task description

				String taskHandle = MylarPlugin.getContextManager().getDominantContextHandleForElement(memberMylarElement);

				if (taskHandle == null){

					return null;

				}

				ITask task = MylarTasklistPlugin.getTaskListManager().getTaskForHandle(taskHandle, false);

				if (task == null){

					return null;

				}

				IMarkupKind kind = new SimpleMarkupKind(task.getDescription(true));

				markupKindSet.add(kind);

				//Set the color

				Color kindColor = UiUtil.getBackgroundForElement(memberMylarElement, true);

				if (kindColor == null || colorTooLight(kindColor)){

					kindColor = defaultStripeColor;

				}

				if (!colorSetByVisualiserMap.containsKey(kind)){

					kindToColorMap.put(kind, kindColor);

				}

				List<IMarkupKind> kindList = new ArrayList<IMarkupKind>();

				kindList.add(kind);

				stripe.setKinds(kindList);

				return stripe;

			}

			return null;

		} catch (RuntimeException e) {

			MylarPlugin.fail(e, "could not get stripe for java member", false);

			return null;

		}

	}

	/** True if the specified stripe color is too light to show up clearly in the visualiser */

	protected boolean colorTooLight(Color color){

		return (color.getRed() > 225 && color.getGreen() > 225 && color.getBlue() > 200);

	}

	/**

	 * Get the markups for a group. Group markups are a stacked set of member markups.

	 * Note: copied from org.eclipse.contribution.visualiser.SimpleMarkupProvider

	 */

	public List getGroupMarkups(IGroup group) {		

		List<Stripe> stripes = new ArrayList<Stripe>();

		List kids = group.getMembers();

		int accumulatedOffset = 0;

		// Go through all the children of the group

		for (Iterator iter = kids.iterator(); iter.hasNext();) {

			IMember element = (IMember) iter.next();

			List l = getMemberMarkups(element);

			if (l != null) {

				for (Iterator iterator = l.iterator(); iterator.hasNext();) {

					Stripe elem = (Stripe) iterator.next();

					stripes.add(new Stripe(elem.getKinds(), elem.getOffset() + accumulatedOffset, elem.getDepth()));

				}

			}

			accumulatedOffset += element.getSize().intValue();

		}	

		return stripes;

	}

	public SortedSet getAllMarkupKinds() {

		return markupKindSet;

	}

	public void setColorFor(IMarkupKind kind, Color color) {

		kindToColorMap.put(kind, color);

		colorSetByVisualiserMap.put(kind, null);

	}

	public Color getColorFor(IMarkupKind kind) {

		Color kindColor = kindToColorMap.get(kind);

		if (kindColor == null){

			kindColor = defaultStripeColor;

		}

		return kindColor;

	}

	/** Go to the member represented by the clicked stripe */

	public boolean processMouseclick(IMember member, Stripe stripe, int buttonClicked) {

		if(buttonClicked != 1){

			return false;	

		}

		if(member instanceof JDTMember) {

			IJavaElement javaElement = ((JDTMember)member).getResource();

			if(javaElement != null) {

				JDTUtils.openInEditor(javaElement.getResource(), JDTUtils.getClassDeclLineNum(javaElement) + stripe.getOffset());

			}

		}

		return false;

	}

	public void activate() {

	}

	public void deactivate() {

	}

}