EDIT

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import org.hibernate.Session;

import org.springframework.beans.factory.BeanFactory;

import eu.etaxonomy.cdm.model.common.VersionableEntity;

import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;

import eu.etaxonomy.cdm.model.name.TypeDesignationBase;

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

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

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

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

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

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

import eu.etaxonomy.cdm.service.IRegistrationWorkingSetService;

import eu.etaxonomy.cdm.service.RegistrationWorkingSetService;

import eu.etaxonomy.cdm.vaadin.model.TypedEntityReference;

import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;

import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationSetManager.TypeDesignationWorkingSet;

import eu.etaxonomy.cdm.vaadin.view.registration.RegistrationDTO;

import eu.etaxonomy.vaadin.ui.view.PopupEditorFactory;

    extends AbstractEditorPresenter<SpecimenTypeDesignationWorkingSetDTO , SpecimenTypeDesignationWorkingsetPopupEditorView> {

    private Reference citation;

    private TaxonName typifiedName;

    private IRegistrationWorkingSetService registrationWorkingSetService;

    protected SpecimenTypeDesignationWorkingSetDTO loadBeanById(Object identifier) {

        SpecimenTypeDesignationWorkingSetDTO workingSetDto;

                RegistrationDTO regDTO = registrationWorkingSetService.loadDtoById(idset.registrationId);

                // find the working set

                TypeDesignationWorkingSet typeDesignationWorkingSet = regDTO.getTypeDesignationWorkingSet(idset.workingsetId);

                workingSetDto = regDTO.getSpecimenTypeDesignationWorkingSetDTO(typeDesignationWorkingSet.getBaseEntityReference());

                citation = (Reference) regDTO.getCitation();

                workingSetDto = fixMissingFieldUnit(workingSetDto);

                FieldUnit newfieldUnit = FieldUnit.NewInstance();

                Registration reg = getRepo().getRegistrationService().load(idset.registrationId,

                        RegistrationWorkingSetService.REGISTRATION_INIT_STRATEGY);

                //TODO checkif passing reg as owner parameter is needed at all

                workingSetDto = new SpecimenTypeDesignationWorkingSetDTO(reg, newfieldUnit, null);

                citation = getRepo().getReferenceService().find(idset.publicationId);

                typifiedName = getRepo().getNameService().find(idset.typifiedNameId);

    private SpecimenTypeDesignationWorkingSetDTO fixMissingFieldUnit(SpecimenTypeDesignationWorkingSetDTO bean) {

        if(bean.getFieldUnit() == null){

            // in case the base unit of the working set is not a FieldUnit all contained TypeDesignations must be modified

            // so that they are based on an empty FieldUnit with an associated Gathering Event

            if(Registration.class.isAssignableFrom(bean.getOwner().getClass())){

                // FIXME open Dialog to warn user about adding an empty fieldUnit to the typeDesignations

                logger.info("Basing all typeDesignations on a new fieldUnit");

                Session session = getSession();

                Registration reg = getRepo().getRegistrationService().find(bean.getOwner().getId());

                RegistrationDTO regDTO = new RegistrationDTO(reg);

                FieldUnit fieldUnit = FieldUnit.NewInstance();

                GatheringEvent gatheringEvent = GatheringEvent.NewInstance();

                fieldUnit.setGatheringEvent(gatheringEvent);

                getRepo().getOccurrenceService().save(fieldUnit);

                VersionableEntity baseEntity = bean.getBaseEntity();

                Set<TypeDesignationBase> typeDesignations = regDTO.getTypeDesignationsInWorkingSet(

                        new TypedEntityReference(baseEntity.getClass(), baseEntity.getId(), baseEntity.toString())

                        );

                for(TypeDesignationBase td : typeDesignations){

                    DerivationEvent de = DerivationEvent.NewInstance();//

                    de.addOriginal(fieldUnit);

                    de.addDerivative(((SpecimenTypeDesignation)td).getTypeSpecimen());

                    de.setType(DerivationEventType.GATHERING_IN_SITU());

                }

                getRepo().getRegistrationService().saveOrUpdate(reg);

                session.flush();

                session.close();

            } else {

                throw new RuntimeException("Usupported owner type " + bean.getOwner().getClass() + ", needs to be implemented.");

            }

        }

        return bean;

    }

        Registration reg = (Registration) dto.getOwner();

        // associate all type designations with the fieldUnit

        // 1. new ones are not yet associated

        // 2. ones which had incomplete data are also not connected

        for(SpecimenTypeDesignationDTO stdDTO : dto.getSpecimenTypeDesignationDTOs()){

            try {

                SpecimenOrObservationBase<?> original = findEarliestOriginal(stdDTO.asSpecimenTypeDesignation().getTypeSpecimen());

                if(original instanceof DerivedUnit){

                    DerivedUnit du = (DerivedUnit)original;

                    du.getDerivedFrom().addOriginal(dto.getFieldUnit());

                }

            } catch (Exception e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        // add newly added typeDesignations

        Set<SpecimenTypeDesignation> addCandidates = new HashSet<>();

        for(SpecimenTypeDesignationDTO stdDTO : dto.getSpecimenTypeDesignationDTOs()){

            SpecimenTypeDesignation std = stdDTO.asSpecimenTypeDesignation();

            if(reg.getTypeDesignations().isEmpty() || !reg.getTypeDesignations().stream().filter(td -> td.equals(std)).findFirst().isPresent()){

                std.setCitation(citation);

                typifiedName.addTypeDesignation(std, false);

                addCandidates.add(std);

            }

        }

        addCandidates.forEach(std -> reg.addTypeDesignation(std));

        getStore().saveBean(reg);

     * @param std

     * @return

     * @throws Exception

    private SpecimenOrObservationBase<?> findEarliestOriginal(DerivedUnit du) throws Exception {

        SpecimenOrObservationBase original = du;

        while(du != null && du.getDerivedFrom() != null && !du.getDerivedFrom().getOriginals().isEmpty()) {

            Iterator<SpecimenOrObservationBase> it = du.getDerivedFrom().getOriginals().iterator();

            SpecimenOrObservationBase nextOriginal = it.next();

            if(nextOriginal == null){

                break;

            }

            original = nextOriginal;

            if(original instanceof DerivedUnit){

                du = (DerivedUnit)original;

            } else {

                // so this must be a FieldUnit,

               break;

            }

            if(it.hasNext()){

                throw new Exception(String.format("%s has more than one originals", du.toString()));

            }

        }

        return original;

     * @param crud

    public void setGrantsForCurrentUser(EnumSet<CRUD> crud) {

        this.crud = crud;