EDIT

package eu.etaxonomy.taxeditor.editor.view.derivate;

import java.util.ArrayList;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.eclipse.jface.viewers.ITreeContentProvider;

import org.eclipse.jface.viewers.TreeNode;

import org.eclipse.jface.viewers.Viewer;

import eu.etaxonomy.cdm.api.service.IOccurrenceService;

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;

import eu.etaxonomy.taxeditor.store.CdmStore;

public class DerivateContentProvider implements ITreeContentProvider {

	@Override

	public void dispose() {

		// TODO Auto-generated method stub

	}

	@Override

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

	}

	@Override

	public Object[] getElements(Object inputElement) {

	    List<TreeNode> rootElements = new ArrayList<TreeNode>();

	    if(inputElement instanceof DerivateViewEditorInput){

	        Set<UUID> rootUUIDs = ((DerivateViewEditorInput) inputElement).getRootUUIDs();

	        for (UUID uuid : rootUUIDs) {

	            SpecimenOrObservationBase<?> rootElement = CdmStore.getService(IOccurrenceService.class).load(uuid);

                if(rootElement!=null){

                    rootElements.add(new TreeNode(rootElement));

                }

            }

	    }

	    return rootElements.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);

            }

            return children.toArray();

        }

        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();

        }

        else 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();

        }

        else 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;

	}

}