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.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.IPersistableElement;

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.ITaxonNodeService;

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

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

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.model.taxon.TaxonRelationshipType;

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

import eu.etaxonomy.taxeditor.editor.CdmEntitySessionInput;

import eu.etaxonomy.taxeditor.editor.ChooseFromMultipleTaxonNodesDialog;

import eu.etaxonomy.taxeditor.editor.TaxonEditorInputFactory;

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

import eu.etaxonomy.taxeditor.model.DataChangeBridge;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 *

 * @author pplitzner

 * @date Aug 24, 2017

 *

 */

public class TaxonEditorInputE4  extends CdmEntitySessionInput implements IEditorInput, IConversationEnabled, IPersistableElement {

    private static final String INCORRECT_STATE = Messages.TaxonEditorInput_INCORRECT_STATE;

    private final ConversationHolder conversation;

    private TaxonNode taxonNode;

    private TaxonEditorInputDataChangeBehaviourE4 dataChangeBehavior;

    private TaxonBase initiallySelectedTaxonBase;

    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) {

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

        if(taxonNode == null){

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

        }

        init(taxonNode);

    }

    private void initForTaxonBase(UUID taxonBaseUuid) {

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

        if (taxonBase != null){

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

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

                setInitiallySelectedTaxonBase(taxon);

                if (taxon.getTaxonNodes().size() == 0 && taxon.isMisapplication()){

                    // 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().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){

                            acceptedTaxa.add(relation.getToTaxon());

                        }

                    }

                    setInputForMultipleTaxa(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){

        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();

            init(taxonNode);

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

            TaxonNode taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(taxonNodes);

            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);

        }

    }

    public static TaxonEditorInputE4 NewInstance(UUID taxonNodeUuid) throws Exception {

        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);

    }

    @Override

    public boolean exists() {

        return taxonNode != null;

    }

    @Override

    public ImageDescriptor getImageDescriptor() {

        return null;

    }

    @Override

    public String getName() {

        if(getTaxon() == null){

            return null;

        }

        TaxonName name = getTaxon().getName();

        if (name == null || name.getTitleCache() == null) {

            return Messages.TaxonEditorInput_NEW_TAXON;

        } else {

            return name.getTitleCache();

        }

    }

    @Override

    public IPersistableElement getPersistable() {

        return null;

    }

    @Override

    public String getToolTipText() {

        return getName();

    }

    /** {@inheritDoc} */

    @Override

    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(){

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

        return taxon;

    }

    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);

    }

    @Override

    public String getFactoryId() {

        return TaxonEditorInputFactory.getFactoryId();

    }

    /** {@inheritDoc} */

    @Override

    public void saveState(IMemento memento) {

        TaxonEditorInputFactoryE4.saveState(memento, this);

    }

    public void setInitiallySelectedTaxonBase(TaxonBase taxonBase) {

        this.initiallySelectedTaxonBase = taxonBase;

    }

    public TaxonBase getInitiallySelectedTaxonBase() {

        return initiallySelectedTaxonBase;

    }

    @Override

    public List<TaxonNode> getRootEntities() {

        return Arrays.asList(taxonNode);

    }

    @Override

    public void merge() {

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

    }

    @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$

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

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

                "relationsFromThisTaxon", //$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", //$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.synonymRelations.synonym.name.status", //$NON-NLS-1$

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

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

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

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

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

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

        });

        return taxonBasePropertyPaths;

    }

}