EDIT

package eu.etaxonomy.taxeditor.view.derivateSearch;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Comparator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.TreeSet;

import org.eclipse.jface.viewers.ITreeContentProvider;

import org.eclipse.jface.viewers.TreeNode;

import org.eclipse.jface.viewers.Viewer;

import eu.etaxonomy.cdm.model.molecular.DnaSample;

import eu.etaxonomy.cdm.model.molecular.Sequence;

import eu.etaxonomy.cdm.model.molecular.SingleRead;

import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;

public class DerivateContentProvider implements ITreeContentProvider {

    private TreeSet<TreeNode> rootNodes;

	@Override

	public void dispose() {

		// TODO Auto-generated method stub

	}

	public List<SpecimenOrObservationBase> getRootElements() {

	    List<SpecimenOrObservationBase> elements = new ArrayList<SpecimenOrObservationBase>();

	    if(rootNodes != null) {

	        for(TreeNode node : rootNodes) {

	            elements.add((SpecimenOrObservationBase)node.getValue());

	        }

	    }

	    return elements;

	}

	@Override

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

	}

	@Override

	public Object[] getElements(Object inputElement) {

	    rootNodes = new TreeSet<TreeNode>(new TreeNodeComparator());

	    if(inputElement instanceof Collection){

	        for (Object o: (Collection)inputElement) {

	            if(o instanceof SpecimenOrObservationBase){

	                SpecimenOrObservationBase<?> rootElement = (SpecimenOrObservationBase<?>)o;

	                if(rootElement!=null){

	                    rootNodes.add(new TreeNode(rootElement));

	                }

	            }

            }

	    }

	    return rootNodes.toArray();

	}

	@Override

	public Object[] getChildren(Object element) {

	    TreeNode currentnode = null;

	    Object value = null;

        if(element instanceof TreeNode){

            currentnode = (TreeNode) element;

            value = ((TreeNode) element).getValue();

        }

        Set<Object> children = new LinkedHashSet<Object>();

        if(value instanceof DnaSample && ((DnaSample) value).getRecordBasis()==SpecimenOrObservationType.DnaSample){

            DnaSample dnaSample = (DnaSample)value;

            Set<Sequence> sequences = dnaSample.getSequences();

            for (Sequence sequence : sequences) {

                TreeNode node = new TreeNode(sequence);

                node.setParent(currentnode);

                children.add(node);

            }

        }

        else if(value instanceof Sequence){

            Set<SingleRead> singleReads = ((Sequence) value).getSingleReads();

            for(SingleRead singleRead:singleReads){

                TreeNode node = new TreeNode(singleRead);

                node.setParent(currentnode);

                children.add(node);

            }

            return children.toArray();

        }

        if(value instanceof SpecimenOrObservationBase){

	        List<DerivedUnit> derivates = getDerivates((SpecimenOrObservationBase<?>) value);

	        for (DerivedUnit derivedUnit:derivates) {

                TreeNode node = new TreeNode(derivedUnit);

                node.setParent(currentnode);

                children.add(node);

            }

            return children.toArray();

	    }

	    return null;

	}

	@Override

	public Object getParent(Object element) {

        if(element instanceof TreeNode){

            return ((TreeNode) element).getParent();

        }

		return null;

	}

	@Override

	public boolean hasChildren(Object element) {

        if(element instanceof TreeNode){

            element = ((TreeNode) element).getValue();

        }

        if(element instanceof DnaSample && ((DnaSample) element).getRecordBasis()==SpecimenOrObservationType.DnaSample){

            DnaSample dnaSample = (DnaSample)element;

            if(!dnaSample.getSequences().isEmpty()){// || !dnaSample.getAmplifications().isEmpty()){

                return true;

            }

        }

        else if(element instanceof Sequence){

            return !((Sequence)element).getSingleReads().isEmpty();

        }

        if(element instanceof SpecimenOrObservationBase){

	        SpecimenOrObservationBase<?> specimenOrObservation = (SpecimenOrObservationBase<?>)element;

	        for(DerivationEvent event:specimenOrObservation.getDerivationEvents()){

	            if(!event.getDerivatives().isEmpty()){

	                return true;

	            }

	        }

	    }

		return false;

	}

	private List<DerivedUnit> getDerivates(SpecimenOrObservationBase<?> specimenOrObservation){

	    List<DerivedUnit> derivates = new ArrayList<DerivedUnit>();

	    for(DerivationEvent derivationEvent:specimenOrObservation.getDerivationEvents()){

	        derivates.addAll(derivationEvent.getDerivatives());

	    }

	    return derivates;

	}

	private class TreeNodeComparator implements Comparator<TreeNode>{

		@Override

		public int compare(TreeNode o1, TreeNode o2) {

			if(o1!=null && o2==null){

				return -1;

			}

			else if(o1==null && o2!=null){

				return 1;

			}

			else if(o1!=null && o2!=null){

				SpecimenOrObservationBase<?> specimenOrObservation1 = (SpecimenOrObservationBase<?>) o1.getValue();

				SpecimenOrObservationBase<?> specimenOrObservation2 = (SpecimenOrObservationBase<?>) o2.getValue();

				return specimenOrObservation1.getTitleCache().compareTo(specimenOrObservation2.getTitleCache());

			}

			return 0;

		}

	}

}