EDIT

/**

* Copyright (C) 2018 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.vaadin.view.name;

import org.hibernate.criterion.Restrictions;

import eu.etaxonomy.cdm.format.reference.ReferenceEllypsisFormatter.LabelType;

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

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

import eu.etaxonomy.cdm.model.reference.NamedSourceBase;

import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;

import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent.Type;

import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;

import eu.etaxonomy.cdm.vaadin.view.reference.RegistrationUiReferenceEditorFormConfigurator;

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

/**

 * @author a.kohlbecker

 * @since Jan 26, 2018

 *

 */

@Scope("prototype")

        extends AbstractCdmEditorPresenter<NameTypeDesignation, NameTypeDesignationEditorView> {

    private IRegistrationWorkingSetService registrationWorkingSetService;

     * The unit of publication in which the type designation has been published.

     * This may be any type listed in {@link RegistrationUIDefaults#NOMECLATURAL_PUBLICATION_UNIT_TYPES}

     * but never a {@link ReferenceType#Section}

     */

        @Override

        public NameTypeDesignation createNewBean() {

            return NameTypeDesignation.NewInstance();

        }

    };

    protected BeanInstantiator<NameTypeDesignation> defaultBeanInstantiator(){

       return defaultBeanInstantiator;

    }

    @Override

    protected NameTypeDesignation loadBeanById(Object identifier) {

        NameTypeDesignationWorkingsetIds idset = (NameTypeDesignationWorkingsetIds)identifier;

        if(idset.isForNewTypeDesignation()) {

            Reference reference = getRepo().getReferenceService().load(idset.getPublishedUnitUuid());

            try {

                    .clone()

                    .extend("typeDesignations", RegistrationWorkingSetService.TYPEDESIGNATION_INIT_STRATEGY, true);

            typifiedNameInContext = getRepo().getNameService().load(idset.getTypifiedNameUuid(), initstrategy.getPropertyPaths());

            bean = super.loadBeanById(null);

            // TODO prevent from errors due to inconsistent data, two options:

            // 1. handle error condition here

            // 2. always set typifiedNameUuid in NameTypeDesignationWorkingsetIds

            typifiedNameInContext = bean.getTypifiedNames().iterator().next();

            try {

                setPublishedUnit(bean.getTypifiedNames().iterator().next().getNomenclaturalSource());

            } catch (Exception e) {

                // FIXME report error state instead

                logger.error("Error on finding published unit in " + bean, e);

            }

        while(typifiedNameNomRef.getType().equals(ReferenceType.Section)

        if (getPublishedUnit() != null) {

            // reduce available references to those which are sections of

            // the publicationUnit and the publishedUnit itself

            referencePagingProvider.getCriteria()

                    .add(Restrictions.or(

                            Restrictions.and(

                            Restrictions.idEq(publishedUnit.getCitation().getId()))

                         );

            // new Reference only a sub sections of the publishedUnit

            newReferenceInstantiator = new BeanInstantiator<Reference>() {

                @Override

                public Reference createNewBean() {

                    Reference newRef = ReferenceFactory.newSection();

                            getPublishedUnit().getCitation().getUuid(),

                            ReferenceEllypsisFormatter.INIT_STRATEGY

                            );

                    newRef.setInReference(reference);

                }

            };

                "source.annotations",

                "source.markers",

                "designationSource.annotations",

                "designationSource.markers",

                "designationSource.links",

        typifiedNamesAsLoaded = new HashSet<>(typeDesignation.getTypifiedNames());

    }

        BeanItemContainer<NameTypeDesignationStatus> container = cdmBeanItemContainerFactory.buildBeanItemContainer(NameTypeDesignationStatus.class);

        List<NameTypeDesignationStatus> filteredItems = container.getItemIds().stream().filter(tsb ->

                )

                .collect(Collectors.toList());

        container.removeAllItems();

        container.addAll(filteredItems);

        return container;

    }

    @Override

    public void handleViewEntered() {

                new ReferenceEllypsisCaptionGenerator(LabelType.BIBLIOGRAPHIC, getView().getDesignationReferenceCombobox().getSelect())

        getView().getDesignationReferenceCombobox().loadFrom(referencePagingProvider, referencePagingProvider, referencePagingProvider.getPageSize());

        getView().getDesignationReferenceCombobox().setNestedButtonStateUpdater(new ToOneRelatedEntityButtonUpdater<Reference>(getView().getDesignationReferenceCombobox()));

        getView().getDesignationReferenceCombobox().getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<>(getView().getDesignationReferenceCombobox(), this));

        getView().getTypifiedNamesComboboxSelect().setPagingProviders(namePagingProvider, namePagingProvider, namePagingProvider.getPageSize(), this);

    @Override

    }

    @Override

    protected void guaranteePerEntityCRUDPermissions(NameTypeDesignation bean) {

        // TODO Auto-generated method stub

    }

    @Override

    protected IService<NameTypeDesignation> getService() {

    }

    protected void deleteBean(NameTypeDesignation bean){

        DeleteResult deletResult = getRepo().getNameService().deleteTypeDesignation(typifiedNameInContext.getUuid(), bean.getUuid());

        } else {

    }

            // having a type name makes no sense in this case, therefore we now remove it now

            bean.setTypeName(null);

        }

        // handle changes explicitly here

        HashSet<TaxonName> typifiedNames = new HashSet<>(bean.getTypifiedNames());

        // handle adds

        for(TaxonName name : typifiedNames){

                throw new NullPointerException("typifiedName must not be null");

            }

                name.addTypeDesignation(bean, false);

            }

        }

        // handle removed

        for(TaxonName name : typifiedNamesAsLoaded){

            if(!typifiedNames.contains(name)){

                name.removeTypeDesignation(bean);

            }

            // FIXME do we need to save the names here or is the delete cascaded from the typedesignation to the name?

        }

        List<Annotation> annotations = getView().getAnnotationsField().getValue();

        List<Annotation> currentAnnotations = new ArrayList<>(bean.getAnnotations());

        List<Annotation> annotationsSeen = new ArrayList<>();

        for(Annotation a : annotations){

            if(a == null){

                continue;

            }

            if(!currentAnnotations.contains(a)){

                bean.addAnnotation(a);

            }

            annotationsSeen.add(a);

        }

        for(Annotation a : currentAnnotations){

            if(!annotationsSeen.contains(a)){

                bean.removeAnnotation(a);

            }

        }

    }

    public void onTaxonNameEditorActionAdd(TaxonNameEditorAction action){

        if(!isFromOwnView(action)){

            return;

        }

        typeNamePopup.withDeleteButton(true);

    }

    @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)

    public void onTaxonNameEditorActionEdit(TaxonNameEditorAction action){

        if(!isFromOwnView(action)){

            return;

        }

        typeNamePopup.withDeleteButton(true);

    }

    public void onReferenceEditorActionAdd(ReferenceEditorAction event) {

        if (getView() == null || event.getSourceView() != getView()) {

            return;

        }

        ReferencePopupEditor referenceEditorPopup = openPopupEditor(ReferencePopupEditor.class, event);

        referenceEditorPopup.grantToCurrentUser(EnumSet.of(CRUD.UPDATE, CRUD.DELETE));

        referenceEditorPopup.withDeleteButton(true);

            .create(newReferenceInstantiator != null)

            .configure(referenceEditorPopup, newReferenceInstantiator);

        referenceEditorPopup.loadInEditor(null);

    @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)

    public void onReferenceEditorActionEdit(ReferenceEditorAction event) {

        if (!isFromOwnView(event)) {

            return;

        }

        ReferencePopupEditor referenceEditorPopup = openPopupEditor(ReferencePopupEditor.class, event);

        referenceEditorPopup.withDeleteButton(true);

        // RegistrationUiReferenceEditorFormConfigurator as spring bean,

        // different spring profiles

        // see also similar methods in TaxonName and SpecimenTypeDesigationEditors

        RegistrationUiReferenceEditorFormConfigurator

            .create(newReferenceInstantiator != null)

            .configure(referenceEditorPopup, newReferenceInstantiator);

        referenceEditorPopup.loadInEditor(event.getEntityUuid());

        if(boundTargetField != null){

            if(boundTargetField.matchesPropertyIdPath("typeName")){

                if(event.isCreateOrModifiedType()){

                    getCache().load(event.getEntity());

                    if(event.isCreatedType()){

                        getView().getTypeNameField().setValue((TaxonName) event.getEntity());

                    } else {

                        getView().getTypeNameField().reload();

                    }

                }

                if(event.isRemovedType()){

                    getView().getTypeNameField().selectNewItem(null);

    }

     * @return

     *  the {@link #publishedUnit}

     */

    }

    /**

     * @param publishedUnit

     *  The unit of publication in which the type designation has been published.

     *  This may be any type listed in {@link RegistrationUIDefaults#NOMECLATURAL_PUBLICATION_UNIT_TYPES}

     */

            throw new NullPointerException();

        }

        if(publishedUnit.getCitation() == null) {

            throw new NullPointerException("The citation of the published unit must not be null.");

        }

        if(!RegistrationUIDefaults.NOMECLATURAL_PUBLICATION_UNIT_TYPES.contains(publishedUnit.getCitation().getType())) {

            throw new Exception("The referrence type '"  + publishedUnit.getType() + "'is not allowed for publishedUnit.");

        }

        this.publishedUnit = publishedUnit;

    }