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.

*/

import java.util.Collection;

import java.util.List;

import java.util.Map;

import com.vaadin.data.Property.ValueChangeListener;

import com.vaadin.ui.TextField;

import eu.etaxonomy.cdm.vaadin.permission.CdmEditDeletePermissionTester;

/**

 * @author a.kohlbecker

 * @since May 22, 2017

 *

 */

@Scope("prototype")

    private static final long serialVersionUID = -7037436241474466359L;

    private final static int GRID_COLS = 4;

    private static final boolean HAS_BASIONYM_DEFAULT = false;

    private TextField genusOrUninomialField;

    private TextField infraGenericEpithetField;

    private TextField specificEpithetField;

    private TextField infraSpecificEpithetField;

    private SwitchableTextField protectedNameCacheField;

    private TextField nomenclaturalReferenceDetail;

    private TeamOrPersonField basionymAuthorshipField;

    private CheckBox basionymToggle;

    private TeamOrPersonField exCombinationAuthorshipField;

    private Boolean isInferredBasionymAuthorship = null;

    private Boolean isInferredExBasionymAuthorship = null;

     * @param layout

     * @param dtoType

     */

    public TaxonNamePopupEditor() {

    /**

     * {@inheritDoc}

     */

    @Override

    public String getWindowCaption() {

        return "Name editor";

    }

    /**

     * {@inheritDoc}

     */

    @Override

     * {@inheritDoc}

     */

    @Override

    public void focusFirst() {

        // titleField.focus();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected String getDefaultComponentStyles() {

        return "tiny";

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void initContent() {

        GridLayout grid = (GridLayout)getFieldLayout();

        grid.setColumnExpandRatio(1, 0.3f);

        grid.setColumnExpandRatio(2, 0.3f);

        grid.setColumnExpandRatio(3, 0.0f);

        /*

         - nameType: preset, needs to be set in the presenter for new names

         - appendedPhrase: -> TODO field

         - nomenclaturalMicroReference:  -> TODO field

         - nomenclaturalReference ->  field but disabled for REGISTRY

         - rank -> SelectField which determines the visiblity of the other fields

         - fullTitleCache + protectedFullTitleCache -> SwitchableTextField : ADVANCED_MODE

         - nameCache + protectedNameCache -> SwitchableTextField : ADVANCED_MODE

         - homotypicalGroup -> hidden

         - typeDesignations -> hidden

         - descriptions -> hidden

         - taxonBases -> hidden

         - registrations -> hidden

         - relationsFromThisName-> TODO implement later

         - relationsToThisName -> TODO implement later

         - genusOrUninomial -> textField

         - infraGenericEpithet  -> textField

         - specificEpithet  -> textField

         - infraSpecificEpithet  -> textField

         - authorshipCache + protectedAuthorshipCache -> SwitchableTextField : only ADVANCED_MODE and disabled for REGISTRY

         - basionymAuthorship -> field but disabled for REGISTRY, basionym is set as nameRelationShip

         - combinationAuthorship -> field but disabled for REGISTRY author team of the reference

         - exCombinationAuthorship -> textField

         - exBasionymAuthorship -> textField

         - status -> TODO field

         - monomHybrid -> TODO implement hybrids later

         - binomHybrid -> TODO implement hybrids later

         - trinomHybrid -> TODO implement hybrids later

         - hybridParentRelations -> TODO implement hybrids later

         - hybridChildRelations -> TODO implement hybrids later

         - hybridFormula -> TODO implement hybrids later

         ** ViralName attributes **

         - acronym

         ** BacterialName attributes **

         - subGenusAuthorship

         - nameApprobation

         - breed

         - publicationYear

         - originalPublicationYear

         - cultivarName

        */

        int row = 0;

        rankSelect.setRows(1);

        basionymToggle = new CheckBox("With basionym");

        basionymToggle.setValue(HAS_BASIONYM_DEFAULT);

        grid.addComponent(basionymToggle, 2, row, 3, row);

        grid.setComponentAlignment(basionymToggle, Alignment.BOTTOM_LEFT);

        row++;

                boolean enable = e.getProperty().getValue() != null && (Boolean)e.getProperty().getValue();

                exCombinationAuthorshipField.setVisible(enable);

            });

        grid.addComponent(validationToggle, 2, row, 3, row);

        grid.setComponentAlignment(validationToggle, Alignment.BOTTOM_LEFT);

        // fullTitleCache

        fullTitleCacheFiled.setWidth(100, Unit.PERCENTAGE);

        protectedNameCacheField.setWidth(100, Unit.PERCENTAGE);

        genusOrUninomialField = addTextField("Genus or uninomial", "genusOrUninomial", 0, row, 1, row);

        genusOrUninomialField.setWidth(200, Unit.PIXELS);

        infraGenericEpithetField = addTextField("Infrageneric epithet", "infraGenericEpithet", 2, row, 3, row);

        infraGenericEpithetField.setWidth(200, Unit.PIXELS);

        row++;

        specificEpithetField = addTextField("Specific epithet", "specificEpithet", 0, row, 1, row);

        specificEpithetField.setWidth(200, Unit.PIXELS);

        infraSpecificEpithetField = addTextField("Infraspecific epithet", "infraSpecificEpithet", 2, row, 3, row);

        infraSpecificEpithetField.setWidth(200, Unit.PIXELS);

        row++;

        grid.addComponent(new Label("Hint: <i>Edit nomenclatural authors in the nomenclatural reference.</i>", ContentMode.HTML), 0, row, 3, row);

        addField(combinationAuthorshipField, "combinationAuthorship", 0, row, GRID_COLS-1, row);

                this,

        nomReferenceCombobox.addClickListenerEditEntity(e -> {

            if(nomReferenceCombobox.getValue() != null){

                            this)

                );

            }

            });

        nomReferenceCombobox.getSelect().addValueChangeListener(e -> logger.debug("nomReferenceCombobox value changed #1"));

        nomReferenceCombobox.setWidth("100%");

        nomenclaturalReferenceDetail = addTextField("Reference detail", "nomenclaturalMicroReference", 3, row, 3, row);

        nomenclaturalReferenceDetail.setWidth(100, Unit.PIXELS);

        addField(exCombinationAuthorshipField, "exCombinationAuthorship", 0, row, GRID_COLS-1, row);

        row++;

        basionymsComboboxSelect.setConverter(new SetToListConverter<TaxonName>());

        addField(basionymsComboboxSelect, "basionyms", 0, row, 3, row);

        basionymsComboboxSelect.setWidth(100, Unit.PERCENTAGE);

        basionymsComboboxSelect.withEditButton(true);

            Object fieldValue = e.getSource().getValue();

            }

            getViewEventBus().publish(this, new TaxonNameEditorAction(e.getAction(), beanUuid, lazyCombobox, this));

        grid.setComponentAlignment(basionymsComboboxSelect, Alignment.TOP_RIGHT);

        addField(basionymAuthorshipField, "basionymAuthorship", 0, row, GRID_COLS-1, row);

        addField(exBasionymAuthorshipField, "exBasionymAuthorship", 0, row, GRID_COLS-1, row);

        registerAdvancedModeComponents(fullTitleCacheFiled, protectedNameCacheField);

        registerAdvancedModeComponents(combinationAuthorshipField);

        registerAdvancedModeComponents(basionymAuthorshipField);

        registerAdvancedModeComponents(exBasionymAuthorshipField);

        registerAdvancedModeComponents(exCombinationAuthorshipField.getCachFields());

        registerAdvancedModeComponents(exBasionymAuthorshipField.getCachFields());

    }

        List<TaxonName> basionyms = basionymsComboboxSelect.getValue();

        if(!basionyms.isEmpty()){

            TaxonName basionym = basionyms.get(0);

                return basionym.getCombinationAuthorship();

            } else if(basionym.getNomenclaturalReference() != null){

                return basionym.getNomenclaturalReference().getAuthorship();

    }

        List<TaxonName> basionyms = basionymsComboboxSelect.getValue();

        if(!basionyms.isEmpty()){

            TaxonName basionym = basionyms.get(0);

        }

        return null;

    }

        Reference nomRef = nomReferenceCombobox.getValue();

        if(nomRef != null) {

            return nomRef.getAuthorship();

        return null;

    protected void afterItemDataSourceSet() {

                || taxonName.getBasionymAuthorship() != null

                || taxonName.getExBasionymAuthorship() != null;

        basionymToggle.setValue(showBasionymSection);

            updateAuthorshipFields();

            updateFieldVisibility();

        });

        boolean showExAuthors = taxonName.getExCombinationAuthorship() != null;

        validationToggle.setValue(showExAuthors);

        validationToggle.setReadOnly(showExAuthors);

            updateAuthorshipFields();

                nomReferenceCombobox.setRequired(true);

            } else {

                combinationAuthorshipField.addValueChangeListener(e -> {

                    if(e.getProperty().getValue() == null){

                        nomReferenceCombobox.setRequired(true);

                    }

                });

            }

        }

     * @param taxonName

     */

    @Override

    public void updateAuthorshipFields() {

        // ------------- CombinationAuthors

                nomReferenceCombobox.getSelect(),

                isInferredCombinationAuthorship);

        // ------------- Basionym and ExBasionymAuthors

        if(BooleanUtils.isTrue(basionymToggle.getValue())){

                    basionymsComboboxSelect,

                    isInferredBasionymAuthorship

                    );

                    );

        updateFieldVisibility();

//     *

//     */

//    protected void updateAuthorshipFieldsVisibility() {

//        combinationAuthorshipField.setVisible(!isInferredCombinationAuthorship);

//        if(BooleanUtils.isTrue(basionymToggle.getValue())){

//            basionymAuthorshipField.setVisible(!isInferredBasionymAuthorship);

//            exBasionymAuthorshipField.setVisible(!isInferredExBasionymAuthorship);

//        }

//    }

     *

     * @param authorship

     *    the value of the taxonName authorship field

     * @param inferredAuthors

     *    the value inferred from other fields which may be set as authorship to the taxon name

     * @param authorshipField

     *    the ui element to edit the taxonName authorship field

     * @param updateTriggerField

     * @param lastInferredAuthorshipState

     * @return

     */

            Boolean lastInferredAuthorshipState) {

        if(authorship == null){

            authorshipField.setValue(inferredAuthors);

            lastInferredAuthorshipState = true;

        } else {

            boolean authorshipMatch = authorship == inferredAuthors;

            if(lastInferredAuthorshipState == null){

            }

            if(!authorshipMatch && lastInferredAuthorshipState){

                // update the combinationAuthorshipField to follow changes of the nomenclatural reference in case it was autofilled before

                authorshipField.setValue(inferredAuthors);

                lastInferredAuthorshipState = true;

            }

        }

        if(updateTriggerField != null){

            // IMPORTANT!

            // this ChangeListener must be added at this very late point in the editor lifecycle so that it is called after

            // the ToOneRelatedEntityReloader which may have been added to the updateTriggerField in the presenters handleViewEntered() method.

            // Otherwise we risk multiple representation problems in the hibernate session

            if(!authorshipUpdateListeners.containsKey(updateTriggerField)){

                ValueChangeListener listener = e ->  {

                    logger.debug(" value changed #2");

                    updateAuthorshipFields();

                };

                updateTriggerField.addValueChangeListener(listener);

                authorshipUpdateListeners.put(updateTriggerField, listener);

            }

        }

    }

    /**

     * @param rank

     * @return

     */

    private void updateFieldVisibility() {

        // TODO use getField() instead and remove field references

        boolean isSpeciesOrBelow = !rank.isHigher(Rank.SPECIES());

        Boolean withBasionym = BooleanUtils.isTrue(basionymToggle.getValue());

        Boolean withValidation = BooleanUtils.isTrue(validationToggle.getValue());

        basionymAuthorshipField.setVisible(withBasionym != null && withBasionym);

        exBasionymAuthorshipField.setVisible(withBasionym);

        basionymsComboboxSelect.setVisible(withBasionym);

        if(BooleanUtils.isTrue(basionymToggle.getValue())){

            basionymAuthorshipField.setVisible(isInferredBasionymAuthorship != null && !isInferredBasionymAuthorship);

            exBasionymAuthorshipField.setVisible(isInferredExBasionymAuthorship != null && !isInferredExBasionymAuthorship);

//            if(modesActive.contains(TaxonNamePopupEditorMode.AUTOFILL_AUTHORSHIP_DATA)){

//            }

//        }

        specificEpithetField.setVisible(isSpeciesOrBelow);

        infraGenericEpithetField.setVisible(rank.isInfraGenericButNotSpeciesGroup());

        genusOrUninomialField.setCaption(isSpeciesOrBelow ? "Genus" : "Uninomial");

        exCombinationAuthorshipField.setVisible(isSpeciesOrBelow && withValidation);

    }

    public void cancel() {

        authorshipUpdateListeners.keySet().forEach(field -> field.removeValueChangeListener(authorshipUpdateListeners.get(field)));

        super.cancel();

    }

     * {@inheritDoc}

     */

    @Override

    public boolean allowAnonymousAccess() {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Collection<Collection<GrantedAuthority>> allowedGrantedAuthorities() {

        return null;

    }

     * {@inheritDoc}

     */

    @Override

    public ToOneRelatedEntityCombobox<Reference> getNomReferenceCombobox() {

        return nomReferenceCombobox;

    }

     * {@inheritDoc}

     */

    @Override

        return basionymsComboboxSelect;

     * {@inheritDoc}

     */

    @Override

    public ListSelect getRankSelect() {

        return rankSelect;

    }

     * @return the exBasionymAuthorshipField

     */

    @Override

    public TeamOrPersonField getExBasionymAuthorshipField() {

        return exBasionymAuthorshipField;

    }

    /**

     * @return the basionymAuthorshipField

     */

    @Override

    public TeamOrPersonField getBasionymAuthorshipField() {

        return basionymAuthorshipField;

    }

    /**

     * @return the combinationAuthorshipField

     */

    @Override

    public TeamOrPersonField getCombinationAuthorshipField() {

        return combinationAuthorshipField;

    }

    /**

     * @return the exCombinationAuthorshipField

     */

    @Override

    public TeamOrPersonField getExCombinationAuthorshipField() {

        return exCombinationAuthorshipField;

    }

    public void enableMode(TaxonNamePopupEditorMode mode){

    public boolean isModeEnabled(TaxonNamePopupEditorMode mode){

        return modesActive.contains(mode);

    }

    public void disableMode(TaxonNamePopupEditorMode mode){

        modesActive.remove(mode);

    }

    public EnumSet<TaxonNamePopupEditorMode> getModesActive(){

        return modesActive;

    }

    public CheckBox getBasionymToggle() {

        return basionymToggle;

    }

     * {@inheritDoc}

     */

    @Override

    public void setReadOnly(boolean readOnly) {

        boolean basionymToggleReadonly = basionymToggle.isReadOnly();

        boolean validationToggleReadonly = validationToggle.isReadOnly();

        super.setReadOnly(readOnly);

        // preserve old readonly states if they were true

        if(basionymToggleReadonly){

            basionymToggle.setReadOnly(true);

        }

        if(validationToggleReadonly){

            validationToggle.setReadOnly(true);

        }

    }