EDIT

/**

* Copyright (C) 2015 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.operation;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.eclipse.core.commands.ExecutionException;

import org.junit.Assert;

import org.junit.Ignore;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

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.api.service.UpdateResult;

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

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

import eu.etaxonomy.cdm.model.description.DescriptionElementSource;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.description.TextData;

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.name.operation.CreateSynonymInExistingHomotypicalGroupOperation;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author cmathew

 * @date 3 Feb 2015

 *

 */

@DataSet

public class TaxonNameEditorTest extends BaseOperationTest {

    @SuppressWarnings("unused")

	private static final Logger logger = Logger.getLogger(TaxonNameEditorTest.class);

    ITaxonNodeService taxonNodeService = getRemoteApplicationController().getTaxonNodeService();

    ITaxonService taxonService = getRemoteApplicationController().getTaxonService();

    IClassificationService classificationService = getRemoteApplicationController().getClassificationService();

    Language english = Language.getLanguageFromUuid(Language.uuidEnglish);

    @Test

    public void testAddHomotypicSynonym() throws ExecutionException {

        UUID taxonNodeUuid = UUID.fromString("ce54c396-3694-47f2-abb0-1d7b7e057985");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        Taxon taxon = taxonNode.getTaxon();

        HomotypicalGroup group = taxon.getHomotypicGroup();

        TaxonName newSynonymName = TaxonNameFactory.NewBotanicalInstance(null);

        newSynonymName.setTitleCache("New Synonym", true);

        operation = new CreateSynonymInExistingHomotypicalGroupOperation("Create Synonym In Existing Homotypical Group",

                undoContext, taxon, group, newSynonymName, postOperation);

        operation.execute(monitor, info);

        taxonNodeService.merge(taxonNode);

        Assert.assertEquals(taxon.getHomotypicGroup().getTypifiedNames().size(), 2);

        Assert.assertEquals(taxon.getSynonyms().size(), 1);

        Iterator<Synonym> synonymItr = taxon.getSynonyms().iterator();

        Synonym synonym = synonymItr.next();

        Assert.assertTrue(taxon.getHomotypicGroup().getTypifiedNames().contains(synonym.getName()));

    }

    @Test

    public void addHeterotypicSynonym() throws ExecutionException {

        UUID taxonNodeUuid = UUID.fromString("ce54c396-3694-47f2-abb0-1d7b7e057985");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        Taxon taxon = taxonNode.getTaxon();

        HomotypicalGroup group = taxon.getHomotypicGroup();

        TaxonName newSynonymName = TaxonNameFactory.NewBotanicalInstance(null);

        newSynonymName.setTitleCache("New Synonym", true);

        operation = new CreateSynonymInExistingHomotypicalGroupOperation("Create Synonym In Existing Homotypical Group",

                undoContext, taxon, group, newSynonymName, postOperation);

        operation.execute(monitor, info);

        taxonNodeService.merge(taxonNode);

    }

    @Test

    public void addDeleteAddHomotypicSynonym() throws ExecutionException {

        UUID taxonNodeUuid = UUID.fromString("ce54c396-3694-47f2-abb0-1d7b7e057985");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        Taxon taxon = taxonNode.getTaxon();

        HomotypicalGroup group = taxon.getHomotypicGroup();

        TaxonName newSynonymName = TaxonNameFactory.NewBotanicalInstance(null);

        newSynonymName.setTitleCache("New Synonym", true);

        operation = new CreateSynonymInExistingHomotypicalGroupOperation("Create Synonym In Existing Homotypical Group",

                undoContext, taxon, group, newSynonymName, postOperation);

        operation.execute(monitor, info);

        taxonNodeService.merge(taxonNode);

        Assert.assertEquals(taxon.getHomotypicGroup().getTypifiedNames().size(), 2);

        Set<Synonym> synonyms = taxon.getSynonyms();

        for(Synonym synonym : synonyms) {

            taxonService.deleteSynonym(synonym.getUuid(), null);

        }

        taxonNodeService.merge(taxonNode);

        newSynonymName = TaxonNameFactory.NewBotanicalInstance(null);

        newSynonymName.setTitleCache("Another New Synonym", true);

        operation = new CreateSynonymInExistingHomotypicalGroupOperation("Create Synonym In Existing Homotypical Group",

                undoContext, taxon, group, newSynonymName, postOperation);

        operation.execute(monitor, info);

        taxonNodeService.merge(taxonNode);

    }

    @Test

    public void addDeleteAddHomotypicSynonymWithAnnotations() throws ExecutionException {

        UUID taxonNodeUuid = UUID.fromString("ce54c396-3694-47f2-abb0-1d7b7e057985");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        Taxon taxon = taxonNode.getTaxon();

        HomotypicalGroup group = taxon.getHomotypicGroup();

        TaxonName newSynonymName = TaxonNameFactory.NewBotanicalInstance(null);

        newSynonymName.setTitleCache("New Synonym", true);

        operation = new CreateSynonymInExistingHomotypicalGroupOperation("Create Synonym In Existing Homotypical Group",

                undoContext, taxon, group, newSynonymName, postOperation);

        operation.execute(monitor, info);

        taxonNodeService.merge(taxonNode);

        boolean includeUnpublished = true;

        Synonym syn = taxonService.findBestMatchingSynonym("New Synonym", includeUnpublished);

        if (syn != null){

           syn.addAnnotation(Annotation.NewDefaultLanguageInstance("TEst"));

           taxonService.merge(syn);

        }

        Assert.assertEquals(taxon.getHomotypicGroup().getTypifiedNames().size(), 2);

        Set<Synonym> synonyms = taxon.getSynonyms();

        for(Synonym synonym : synonyms) {

            Assert.assertEquals(syn.getUuid(), synonym.getUuid());

            taxonService.deleteSynonym(synonym.getUuid(), null);

        }

        taxonNodeService.merge(taxonNode);

        newSynonymName = TaxonNameFactory.NewBotanicalInstance(null);

        newSynonymName.setTitleCache("Another New Synonym", true);

        operation = new CreateSynonymInExistingHomotypicalGroupOperation("Create Synonym In Existing Homotypical Group",

                undoContext, taxon, group, newSynonymName, postOperation);

        operation.execute(monitor, info);

        taxonNodeService.merge(taxonNode);

    }

    @Test

    public void swapSynonymWithAcceptedTaxon() throws ExecutionException {

        List<TaxonNode> rootEntities = new ArrayList<TaxonNode>();

        UUID taxonNodeUuid = UUID.fromString("d425a971-1abe-4895-9e1f-1e5c8ff1c84c");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        rootEntities.add(taxonNode);

        UUID taxonUuid = UUID.fromString("9763e5f0-6cd4-4d96-b8a4-4420854f7727");

        Taxon taxon = (Taxon)taxonService.load(taxonUuid);

        TaxonName taxonName = taxon.getName();

        UUID synonymUuid = UUID.fromString("1eb173bd-b174-4162-8ff5-5136d8f1e746");

        Synonym synonym = (Synonym)taxonService.load(synonymUuid);

        TaxonName synonymName = synonym.getName();

        UpdateResult result = taxonService.swapSynonymAndAcceptedTaxon(synonym.getUuid(), taxon.getUuid(), false);

        taxon = (Taxon)result.getCdmEntity();

        Set<TaxonName> synNames = taxon.getSynonymNames();

        Iterator<TaxonName> iterator = synNames.iterator();

        if(iterator.hasNext()){

            Assert.assertEquals(synonymName, iterator.next());

        }else{

            Assert.fail();

        }

        Assert.assertEquals(synonymName, taxon.getName());

    }

    @Test

    public void addTaxon() {

        INonViralName taxonName = TaxonNameFactory.NewNonViralInstance(null);

        Taxon taxon = Taxon.NewInstance(taxonName, null);

        taxon = (Taxon)taxonService.merge(taxon);

        taxon.getName().addTypeDesignation(NameTypeDesignation.NewInstance(), true);

    }

    @Ignore

    @Test

    public void addDescription() {

        UUID taxonNodeUuid = UUID.fromString("ce54c396-3694-47f2-abb0-1d7b7e057985");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        Taxon taxon = taxonNode.getTaxon();

        TaxonDescription description = TaxonDescription.NewInstance(taxon);

        TextData textData = TextData.NewInstance();

        textData.setFeature(Feature.ECOLOGY());

        description.addElement(textData);

        DescriptionElementSource descriptionElementSource = DescriptionElementSource.NewInstance(OriginalSourceType.PrimaryTaxonomicSource);

        textData.addSource(descriptionElementSource);

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

        description.getId();

    }

    @Test

    public void addTaxonNodeCascadeProblem() {

        UUID taxonNodeUuid = UUID.fromString("ce54c396-3694-47f2-abb0-1d7b7e057985");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        Taxon childTaxon = Taxon.NewInstance(null, null);

        TaxonNode childTaxonNode = taxonNode.addChildTaxon(childTaxon, null, null);

        Taxon grandChildTaxon = Taxon.NewInstance(null, null);

        TaxonNode grandChildTaxonNode = childTaxonNode.addChildTaxon(grandChildTaxon, null, null);

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

        Assert.assertEquals(taxonNode.getChildNodes().get(0).getId(), childTaxonNode.getId());

        Assert.assertTrue(childTaxonNode.treeIndex() != null);

        Assert.assertEquals(taxonNode.getChildNodes().get(0).treeIndex(), childTaxonNode.treeIndex());

        Assert.assertFalse(childTaxon.getId() == 0);

        Assert.assertEquals(taxonNode.getChildNodes().get(0).getTaxon().getId(), childTaxon.getId());

        Assert.assertTrue(grandChildTaxonNode.treeIndex() != null);

        Assert.assertEquals(taxonNode.getChildNodes().get(0).getChildNodes().get(0).getId(), grandChildTaxonNode.getId());

        Assert.assertFalse(grandChildTaxon.getId() == 0);

        Assert.assertEquals(taxonNode.getChildNodes().get(0).getChildNodes().get(0).getTaxon().getId(), grandChildTaxon.getId());

    }

}