EDIT

/**

* Copyright (C) 2017 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 java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.hibernate.Session;

import org.vaadin.viritin.fields.AbstractElementCollection;

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

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

import eu.etaxonomy.cdm.model.location.Country;

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

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

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

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

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.model.reference.Reference;

import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;

import eu.etaxonomy.cdm.service.CdmStore;

import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;

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

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

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

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

import eu.etaxonomy.cdm.vaadin.util.CdmTitleCacheCaptionGenerator;

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

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

import eu.etaxonomy.vaadin.mvp.AbstractEditorPresenter;

/**

 * SpecimenTypeDesignationWorkingsetPopupEditorView implementation must override the showInEditor() method,

 * see {@link #prepareAsFieldGroupDataSource()} for details.

 *

 * @author a.kohlbecker

 * @since Jun 13, 2017

 *

 */

public class SpecimenTypeDesignationWorkingsetEditorPresenter

    extends AbstractEditorPresenter<SpecimenTypeDesignationWorkingSetDTO , SpecimenTypeDesignationWorkingsetPopupEditorView> {

    private static final long serialVersionUID = 4255636253714476918L;

    private List<String> specimenTypeDesignationWorkingsetInitStrategy = Arrays.asList(new String[]{

            "typeDesignations.typeStatus.representations",

            "typeDesignations.typeSpecimen.sources",

            "typeDesignations.typeSpecimen.mediaSpecimen.representations.parts",

            "typeDesignations.typeSpecimen.collection",

            "typeDesignations.typeSpecimen.derivedFrom.type",

            "typeDesignations.typeSpecimen.derivedFrom.derivatives",

            // Need to initialize all properties of the DerivedUnit to avoid LIEs while converting DerivedUnit with the DerivedUnitConverter:

            "typeDesignations.typeSpecimen.*",

    });

    CdmStore<Registration, IRegistrationService> store ;

    protected CdmStore<Registration, IRegistrationService> getStore() {

        if(store == null){

            store = new CdmStore<>(getRepo(), getRepo().getRegistrationService());

        }

        return store;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected SpecimenTypeDesignationWorkingSetDTO loadBeanById(Object identifier) {

        SpecimenTypeDesignationWorkingSetDTO workingSet;

        if(identifier != null){

            RegistrationAndWorkingsetId registrationAndWorkingsetId = (RegistrationAndWorkingsetId)identifier;

            List<Integer> ids = new ArrayList<>();

            ids.add(registrationAndWorkingsetId.registrationId);

            Registration reg = getRepo().getRegistrationService().loadByIds(ids, specimenTypeDesignationWorkingsetInitStrategy).get(0);

            RegistrationDTO regDTO = new RegistrationDTO(reg);

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

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

        } else {

            workingSet = null;

        }

        return workingSet;

    }

    /**

     * {@inheritDoc}

     */

    @SuppressWarnings("serial")

    @Override

    public void handleViewEntered() {

        CdmBeanItemContainerFactory selectFactory = new CdmBeanItemContainerFactory(getRepo());

        getView().getCountrySelectField().setContainerDataSource(selectFactory.buildBeanItemContainer(Country.uuidCountryVocabulary));

        getView().getTypeDesignationsCollectionField().setEditorInstantiator(new AbstractElementCollection.Instantiator<SpecimenTypeDesignationDTORow>() {

            CdmFilterablePagingProvider<Collection> collectionPagingProvider = new CdmFilterablePagingProvider<Collection>(getRepo().getCollectionService(), SpecimenTypeDesignationWorkingsetEditorPresenter.this);

            CdmFilterablePagingProvider<Reference> referencePagingProvider = new CdmFilterablePagingProvider<Reference>(getRepo().getReferenceService(), SpecimenTypeDesignationWorkingsetEditorPresenter.this);

            @Override

            public SpecimenTypeDesignationDTORow create() {

                SpecimenTypeDesignationDTORow row = new SpecimenTypeDesignationDTORow();

                row.derivationEventType.setContainerDataSource(selectFactory.buildTermItemContainer(

                        RegistrationTermLists.DERIVATION_EVENT_TYPE_UUIDS())

                        );

                row.derivationEventType.setNullSelectionAllowed(false);

                row.derivationEventType.addValueChangeListener(e -> {

                    SpecimenTypeDesignationDTORow currentRow = row;

                    updateRowItemEnablement(currentRow);

                });

                row.typeStatus.setContainerDataSource(selectFactory.buildTermItemContainer(

                        RegistrationTermLists.SPECIMEN_TYPE_DESIGNATION_STATUS_UUIDS())

                        );

                row.typeStatus.setNullSelectionAllowed(false);

                row.collection.loadFrom(

                        collectionPagingProvider,

                        collectionPagingProvider,

                        collectionPagingProvider.getPageSize()

                        );

                row.collection.getSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<Collection>());

                row.mediaSpecimenReference.loadFrom(

                        referencePagingProvider,

                        referencePagingProvider,

                        collectionPagingProvider.getPageSize()

                        );

                row.mediaSpecimenReference.getSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<Reference>());

                getView().applyDefaultComponentStyle(row.components());

                updateRowItemEnablement(row);

                return row;

            }

            private void updateRowItemEnablement(SpecimenTypeDesignationDTORow row) {

                DerivationEventType derivationEventType = (DerivationEventType)row.derivationEventType.getValue();

                boolean publishedImageType = derivationEventType != null && derivationEventType.equals(DerivationEventTypes.PUBLISHED_IMAGE());

                boolean unPublishedImageType = derivationEventType != null && derivationEventType.equals(DerivationEventTypes.UNPUBLISHED_IMAGE());

                row.mediaSpecimenReference.setEnabled(publishedImageType);

                row.mediaSpecimenReferenceDetail.setEnabled(publishedImageType);

                row.mediaUri.setEnabled(unPublishedImageType);

            }

        });

    }

    /**

     * {@inheritDoc}

     *

     * see also {@link SpecimenTypeDesignationWorkingsetPopupEditor#showInEditor()}

     */

    @Override

    protected SpecimenTypeDesignationWorkingSetDTO prepareAsFieldGroupDataSource(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 super.prepareAsFieldGroupDataSource(bean);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void saveBean(SpecimenTypeDesignationWorkingSetDTO dto) {

        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(SpecimenTypeDesignation std : dto.getSpecimenTypeDesignations()){

            try {

                SpecimenOrObservationBase<?> original = findEarliestOriginal(std.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(SpecimenTypeDesignation std : dto.getSpecimenTypeDesignations()){

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

                addCandidates.add(std);

            }

        }

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

        getStore().saveBean(reg);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void deleteBean(SpecimenTypeDesignationWorkingSetDTO bean) {

        // TODO Auto-generated method stub

    }

    /**

     * @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;

    }

}