EDIT

/**

 * Copyright (C) 2007 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.taxeditor.editor.e4;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.UUID;

import org.eclipse.e4.ui.di.UISynchronize;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;

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

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

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

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

import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.TaxonBaseDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;

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

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

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

import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;

import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;

import eu.etaxonomy.taxeditor.editor.CdmEntitySessionInput;

import eu.etaxonomy.taxeditor.editor.ChooseFromMultipleAcceptedTaxaDialog;

import eu.etaxonomy.taxeditor.editor.ChooseFromMultipleTaxonNodesDialog;

import eu.etaxonomy.taxeditor.editor.EditorUtil;

import eu.etaxonomy.taxeditor.editor.l10n.Messages;

import eu.etaxonomy.taxeditor.model.DataChangeBridge;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;

import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 *

 * @author pplitzner

 * @date Aug 24, 2017

 *

 */

public class TaxonEditorInputE4  extends CdmEntitySessionInput implements IConversationEnabled {

    private static final String INCORRECT_STATE = Messages.TaxonEditorInput_INCORRECT_STATE;

    private final ConversationHolder conversation;

    private TaxonNode taxonNode;

    private Map<TaxonBase, TaxonBaseDeletionConfigurator> toDeletes = new HashMap<>();

    private Set<Synonym> toSaveNewSynonyms = new HashSet<>();

    private List<TaxonBase> toSaveNewConcepts = new ArrayList<>();

    private List<TaxonName> toSaveNewNames = new ArrayList<>();

    private Set<AbstractPostTaxonOperation> operations = new HashSet<>();

    private TaxonEditorInputDataChangeBehaviourE4 dataChangeBehavior;

    private TaxonBase<?> initiallySelectedTaxonBase;

    private UISynchronize sync;

    public void setSync(UISynchronize sync) {

        this.sync = sync;

    }

    private enum CdmType {

        TAXON_NODE,

        TAXON_BASE,

        PARENT_TAXON_NODE

    }

    private TaxonEditorInputE4(UUID uuid, CdmType type) {

        super(true);

        this.conversation = CdmStore.createConversation();

        switch(type) {

        case PARENT_TAXON_NODE:

            initForParentTaxonNode(uuid);

            break;

        case TAXON_BASE:

            initForTaxonBase(uuid);

            break;

        case TAXON_NODE:

            initForTaxonNode(uuid);

            break;

        }

    }

    private void init(TaxonNode taxonNode) {

    	this.taxonNode = taxonNode;

    }

    private void initForTaxonNode(UUID taxonNodeUuid) {

    	this.getCdmEntitySession().bind();

        TaxonNode taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNodeUuid, getTaxonNodePropertyPaths());

//    	TaxonNode taxonNode = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonNodeService.class), taxonNodeUuid, getTaxonNodePropertyPaths());

        if(taxonNode == null){

            MessagingUtils.warningDialog(Messages.TaxonEditorInput_NOT_IMPLEMENTED, TaxonEditorInputE4.class, Messages.TaxonEditorInput_NOT_IMPLEMENTED_MESSAGE);

        }

        init(taxonNode);

        setInitiallySelectedTaxonBase(getTaxon());

    }

    private void initForTaxonBase(UUID taxonBaseUuid) {

    	this.getCdmEntitySession().bind();

//        TaxonBase taxonBase = CdmStore.getService(ITaxonService.class).load(taxonBaseUuid, getTaxonBasePropertyPaths());

    	TaxonBase taxonBase = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonService.class), taxonBaseUuid, getTaxonBasePropertyPaths());

        if (taxonBase != null){

            if(taxonBase.isInstanceOf(Taxon.class)){

                Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);

                setInitiallySelectedTaxonBase(taxon);

                if ( taxon.isMisapplication() || taxon.isProparteSynonym()){

                    // TODO get accepted taxon

                    MessagingUtils.info(Messages.TaxonEditorInput_OPEN_MISSAPPLIED_NAME);

                    Set<Taxon> acceptedTaxa = new HashSet<Taxon>();

                    Set<TaxonRelationship> relations = taxon.getRelationsFromThisTaxon();

                    for(TaxonRelationship relation : relations){

                        if(relation.getType().isAnyMisappliedName() || relation.getType().isAnySynonym()){

                            acceptedTaxa.add(relation.getToTaxon());

                        }

                    }

                    if (taxon.getTaxonNodes().size() > 0){

                        acceptedTaxa.add(taxon);

                    }

                    setInputForRelatedTaxa(conversation, acceptedTaxa);

                }else{

                    setInputForMultipleNodes(conversation, taxon.getTaxonNodes());

                }

            }else if(taxonBase instanceof Synonym){

                Synonym synonym = (Synonym) taxonBase;

                Set<Taxon> taxa = new HashSet<>();

                Taxon taxon = synonym.getAcceptedTaxon();

                if (taxon != null){

                	taxa.add(taxon);

                }

                setInputForMultipleTaxa(conversation, taxa);

                setInitiallySelectedTaxonBase(synonym);

            }

        }

    }

    private void initForParentTaxonNode(UUID parentNodeUuid){

    	this.getCdmEntitySession().bind();

        TaxonName name = PreferencesUtil.getPreferredNomenclaturalCode().getNewTaxonNameInstance(null);

        ITaxonTreeNode parentNode = CdmStore.getService(IClassificationService.class).getTreeNodeByUuid(parentNodeUuid);

        Taxon newTaxon = Taxon.NewInstance(name, parentNode.getReference());

        TaxonNode newTaxonNode = parentNode.addChildTaxon(newTaxon, parentNode.getReference(), parentNode.getMicroReference());

        // add the new taxon to the editors persistence context

        UUID newTaxonNodeUuid = CdmStore.getService(ITaxonNodeService.class).save(newTaxonNode).getUuid();

        initForTaxonNode(newTaxonNodeUuid);

    }

    private void setInputForMultipleNodes(ConversationHolder conversation, Set<TaxonNode> taxonNodes){

        if(taxonNodes.size() == 1){

            TaxonNode taxonNode = taxonNodes.iterator().next();

            taxonNode = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonNodeService.class), taxonNode.getUuid(), getTaxonNodePropertyPaths());

            init(taxonNode);

        }else if(taxonNodes.size() > 1){

            TaxonNode taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(taxonNodes);

            if(taxonNode != null){

                taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());

            }

            if(taxonNode != null){

                init(taxonNode);

            }

        } else if (taxonNodes.size() == 0) {

            // this is an undesired state

            MessagingUtils.warningDialog(INCORRECT_STATE,TaxonEditorInputE4.class,Messages.TaxonEditorInput_TAXON_NOT_IN_CLASSIFICATION);

        }

    }

    private void setInputForMultipleTaxa(ConversationHolder conversation, Set<Taxon> taxa){

        if(taxa.size() == 1){

            Taxon taxon = taxa.iterator().next();

            Set<TaxonNode> nodes = taxon.getTaxonNodes();

            setInputForMultipleNodes(conversation, nodes);

        }else if(taxa.size() > 1){

            Set<TaxonNode> taxonNodes = new HashSet<TaxonNode>();

            for ( Taxon taxon : taxa ){

                taxonNodes.addAll(taxon.getTaxonNodes());

            }

            setInputForMultipleNodes(conversation, taxonNodes);

        }else if(taxa.size() == 0){

            // this is an undesired state

            MessagingUtils.warningDialog(INCORRECT_STATE, TaxonEditorInputE4.class, Messages.TaxonEditorInput_NO_ACCEPTED_TAXON_PRESENT);

        }

    }

    private void setInputForRelatedTaxa(ConversationHolder conversation, Set<Taxon> taxa){

        if(taxa.size() == 1){

            Taxon taxon = taxa.iterator().next();

            Set<TaxonNode> nodes = taxon.getTaxonNodes();

            TaxonNode taxonNode = null;

            if (nodes.size()>1){

                taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(nodes);

            }else if (nodes.size()==1){

                taxonNode = nodes.iterator().next();

            }else{

                MessagingUtils.warningDialog(INCORRECT_STATE,TaxonEditorInputE4.class,Messages.TaxonEditorInput_TAXON_NOT_IN_CLASSIFICATION);

            }

            init(taxonNode);

        }else if(taxa.size() > 1){

            Iterator<Taxon> taxonIterator = taxa.iterator();

            Set<TaxonNode> nodes = new HashSet<>();

            while (taxonIterator.hasNext()){

                nodes.addAll(taxonIterator.next().getTaxonNodes());

            }

            TaxonNode taxonNode = ChooseFromMultipleAcceptedTaxaDialog.choose(nodes);

            if(taxonNode != null){

                taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());

            }

            if(taxonNode != null){

                init(taxonNode);

            }

        } else if (taxa.size() == 0) {

            // this is an undesired state

            MessagingUtils.warningDialog(INCORRECT_STATE,TaxonEditorInputE4.class,Messages.TaxonEditorInput_TAXON_NOT_IN_CLASSIFICATION);

        }

    }

    public static TaxonEditorInputE4 NewInstance(UUID taxonNodeUuid) {

        return new TaxonEditorInputE4(taxonNodeUuid, CdmType.TAXON_NODE);

    }

    public static TaxonEditorInputE4 NewInstanceFromTaxonBase(UUID taxonBaseUuid){

        return new TaxonEditorInputE4(taxonBaseUuid, CdmType.TAXON_BASE);

    }

    public static TaxonEditorInputE4 NewEmptyInstance(UUID parentNodeUuid){

        return new TaxonEditorInputE4(parentNodeUuid, CdmType.PARENT_TAXON_NODE);

    }

    public Object getAdapter(Class adapter) {

        if (adapter == Taxon.class) {

            return getTaxon();

        }

        if (adapter == TaxonNode.class) {

            return taxonNode;

        }

        return null;

    }

    /**

     * {@inheritDoc}

     *

     * Overrides equals to ensure that a taxon can only be edited by

     * one editor at a time.

     */

    @Override

    public boolean equals(Object obj) {

        if (TaxonEditorInputE4.class.equals(obj.getClass())

                && getTaxon() != null

                && getTaxon().equals(((TaxonEditorInputE4) obj).getTaxon())) {

            if (((TaxonEditorInputE4) obj).getInitiallySelectedTaxonBase() != null){

                setInitiallySelectedTaxonBase(((TaxonEditorInputE4) obj).getInitiallySelectedTaxonBase());

            }

            return true;

        }

        return false;

    }

    public Taxon getTaxon(){

        if(taxonNode!=null){

            Taxon taxon = CdmBase.deproxy(taxonNode.getTaxon(), Taxon.class);

            return taxon;

        }

        return null;

    }

    public TaxonNode getTaxonNode() {

        return taxonNode;

    }

    @Override

    public ConversationHolder getConversationHolder() {

        return conversation;

    }

    /** {@inheritDoc} */

    @Override

    public void update(CdmDataChangeMap events) {

        if(dataChangeBehavior == null){

            dataChangeBehavior = new TaxonEditorInputDataChangeBehaviourE4(this);

        }

        DataChangeBridge.handleDataChange(events, dataChangeBehavior);

    }

    public void setInitiallySelectedTaxonBase(TaxonBase taxonBase) {

        this.initiallySelectedTaxonBase = taxonBase;

    }

    public TaxonBase getInitiallySelectedTaxonBase() {

        return initiallySelectedTaxonBase;

    }

    public Set<AbstractPostTaxonOperation> getOperations() {

        return operations;

    }

    public void setOperations(Set<AbstractPostTaxonOperation> operations) {

        this.operations = operations;

    }

    public void addOperation(AbstractPostTaxonOperation operation) {

        this.operations.add(operation);

    }

    public void addToSaveNewSynonym(Synonym toSaveNew) {

        this.toSaveNewSynonyms.add(toSaveNew);

    }

    public void addToSaveNewConcept(Taxon toSaveNew) {

       this.toSaveNewConcepts.add(toSaveNew);

    }

    @Override

    public List<TaxonNode> getRootEntities() {

        return Arrays.asList(taxonNode);

    }

    @Override

    public void merge() {

        if (!this.getCdmEntitySession().isActive()){

            this.getCdmEntitySession().bind();

        }

        for(Entry<TaxonBase, TaxonBaseDeletionConfigurator> entry:toDeletes.entrySet()){

            delete(entry.getKey(), entry.getValue());

        }

        toDeletes.clear();

        for(AbstractPostOperation entry:operations){

            EditorUtil.executeOperation(entry,sync);

        }

        operations.clear();

        for (Synonym syn: toSaveNewSynonyms){

            for (HybridRelationship rel : syn.getName().getHybridChildRelations()){

//                if (!rel.getParentName().isPersited()) {

                    toSaveNewNames.add(rel.getParentName());

//                }

//                    if (!rel.getHybridName().isPersited()) {

                   toSaveNewNames.add(rel.getHybridName());

//                }

            }

        }

        for (TaxonBase concept: toSaveNewConcepts){

            for (HybridRelationship rel : concept.getName().getHybridChildRelations()){

//                if (!rel.getParentName().isPersited()) {

                    toSaveNewNames.add(rel.getParentName());

//                }

//                if (!rel.getHybridName().isPersited()) {

                    toSaveNewNames.add(rel.getHybridName());

//                }

            }

        }

        CdmStore.getService(INameService.class).merge(toSaveNewNames, true);

        CdmStore.getService(ITaxonService.class).merge(toSaveNewConcepts, true);

        toSaveNewNames.clear();

        toSaveNewConcepts.clear();

        CdmStore.getService(ITaxonNodeService.class).merge(taxonNode, true);

    }

    /**

     * @param key

     * @param value

     */

    private void delete(TaxonBase key, TaxonBaseDeletionConfigurator value) {

        if (key instanceof Synonym){

            CdmStore.getService(ITaxonService.class).deleteSynonym(((Synonym)key).getUuid(), (SynonymDeletionConfigurator) value);

        }else{

            CdmStore.getService(ITaxonService.class).deleteTaxon(((Taxon)key).getUuid(), (TaxonDeletionConfigurator) value, null);

        }

    }

    @Override

    public Map<Object, List<String>> getPropertyPathsMap() {

        return null;

    }

    private List<String> getTaxonNodePropertyPaths() {

        List<String> taxonNodePropertyPaths = new ArrayList<String>();

        for(String propertyPath : getTaxonBasePropertyPaths()) {

            taxonNodePropertyPaths.add("taxon." + propertyPath); //$NON-NLS-1$

        }

        return taxonNodePropertyPaths;

    }

    private List<String> getTaxonBasePropertyPaths() {

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

                "sec", //$NON-NLS-1$

                "createdBy", //$NON-NLS-1$

                "updatedBy", //$NON-NLS-1$

                "annotations", //$NON-NLS-1$

                "markers", //$NON-NLS-1$

                "credits", //$NON-NLS-1$

                "extensions", //$NON-NLS-1$

                "rights", //$NON-NLS-1$

                "sources", //$NON-NLS-1$

                "identifiers",

                "descriptions", //$NON-NLS-1$

                "taxonNodes", //$NON-NLS-1$

                "descriptions.descriptionElements.feature", //$NON-NLS-1$

                "descriptions.descriptionElements.area", //$NON-NLS-1$

                "descriptions.descriptionElements.status", //$NON-NLS-1$

                "descriptions.markers", //$NON-NLS-1$

                "name.descriptions", //$NON-NLS-1$

                "name.typeDesignations.typeSpecimen.derivedFrom.originals", //$NON-NLS-1$

                "name.status", //$NON-NLS-1$

                "name.nomenclaturalReference.inReference", //$NON-NLS-1$

                "name.taxonBases.taxonNodes", //$NON-NLS-1$

                "name.relationsFromThisName", //$NON-NLS-1$

                "name.relationsToThisName", //$NON-NLS-1$

                "name.homotypicalGroup.typifiedNames.taxonBases.synonyms.synonym.name.status", //$NON-NLS-1$

                "name.homotypicalGroup.typifiedNames.relationsToThisName.fromName", //$NON-NLS-1$

                "synonyms.name.status.type", //$NON-NLS-1$

                "synonyms.name.relationsToThisName.fromName", //$NON-NLS-1$

                "synonyms.name.nomenclaturalReference.inReference.authorship", //$NON-NLS-1$

                "synonyms.name.nomenclaturalReference.authorship", //$NON-NLS-1$

                "synonyms.name.homotypicalGroup.typifiedNames.taxonBases.synonyms" //$NON-NLS-1$

        });

        return taxonBasePropertyPaths;

    }

    /**

     * @param selectedElement

     * @param deleteConfig

     */

    public void addTaxonBaseToDelete(TaxonBase selectedElement, TaxonBaseDeletionConfigurator deleteConfig) {

        this.toDeletes.put(selectedElement, deleteConfig);

    }

    /**

     * @param newName

     */

    public void addToSaveNewName(TaxonName newName) {

        this.toSaveNewNames.add(newName);

    }

}