EDIT

// $Id$

/**

* 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.cdm.model;

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

import org.junit.BeforeClass;

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.model.common.Language;

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

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

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

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

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

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.httpinvoker.CDMServer;

import eu.etaxonomy.taxeditor.operations.OperationTestBase;

import eu.etaxonomy.taxeditor.remoting.cache.CdmTransientEntityCacher;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.session.MockSessionOwner;

/**

 * @author cmathew

 * @date 3 Feb 2015

 *

 */

@DataSet

public class TaxonNameEditorTest extends OperationTestBase {

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

    ITaxonNodeService taxonNodeService = getRemoteApplicationController().getTaxonNodeService();

    ITaxonService taxonService = getRemoteApplicationController().getTaxonService();

    IClassificationService classificationService = getRemoteApplicationController().getClassificationService();

    private CdmTransientEntityCacher cacher;

    private ICdmEntitySessionEnabled sessionOwner;

    private ICdmEntitySession cdmEntitySession;

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

    @BeforeClass

    public static void initializePolytomousKeyTest() {

        //logger.setLevel(Level.INFO);

        CDMServer.getInstance().setKeepServerRunning(true);

        initializeController("default",

                "localhost",

                8080,

                "",

                NomenclaturalCode.ICNAFP,

                "admin",

                "00000");

    }

    @Before

    public void initializeSession() {

        sessionOwner = new MockSessionOwner();

        cdmEntitySession = cdmEntitySessionManager.newSession(sessionOwner, true);

        cacher = getCacher(sessionOwner);

    }

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

        BotanicalName newSynonymName = BotanicalName.NewInstance(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();

        BotanicalName newSynonymName = BotanicalName.NewInstance(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();

        BotanicalName newSynonymName = BotanicalName.NewInstance(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(), taxon.getUuid(), null);

        }

        taxonNodeService.merge(taxonNode);

        newSynonymName = BotanicalName.NewInstance(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);

        sessionOwner = new MockSessionOwner(rootEntities);

        cdmEntitySession = cdmEntitySessionManager.newSession(sessionOwner, true);

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

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

        TaxonNameBase taxonName = taxon.getName();

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

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

        TaxonNameBase synonymName = synonym.getName();

        taxonService.swapSynonymAndAcceptedTaxon(synonym.getUuid(), taxon.getUuid());

        Assert.assertEquals(taxonName, synonym.getName());

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

    }

    @Test

    public void addTaxon() {

        NonViralName taxonName = NonViralName.NewInstance(null);

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

        taxonService.merge(taxon);

    }

}