EDIT

// $Id$

/**

 * Copyright (C) 2014 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.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.hibernate.collection.spi.PersistentCollection;

import org.junit.Assert;

import org.junit.BeforeClass;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

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

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

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

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

import eu.etaxonomy.cdm.model.agent.AgentBase;

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.media.Rights;

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

import eu.etaxonomy.taxeditor.httpinvoker.RemotingSessionAwareTest;

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

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.session.MockSessionOwner;

/**

 * @author cmathew

 * @date 7 Oct 2014

 *

 */

@DataSet

public class PolytomousKeyTest extends RemotingSessionAwareTest {

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

    UUID polytomousKeyUuid = UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66");

    UUID subKeyUuid = UUID.fromString("9d8bf4f6-a70a-4b80-8556-2ccfb436ff01");

    //UUID polytomousKeyUuid = UUID.fromString("bab66772-2c83-428a-bb6d-655d12ac6097");

    UUID taxon1Uuid = UUID.fromString("2b336df7-29e8-4f79-985f-66502739d22f");

    IPolytomousKeyService polytomousKeyService = getRemoteApplicationController().getPolytomousKeyService();

    IPolytomousKeyNodeService polytomousKeyNodeService = getRemoteApplicationController().getPolytomousKeyNodeService();

    ICommonService commonService = getRemoteApplicationController().getCommonService();

    ITaxonService taxonService = getRemoteApplicationController().getTaxonService();

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

    @BeforeClass

    public static void initializePolytomousKeyTest() {

    }

    @Test

    public void readAllPolytomousKeys() {

        List<PolytomousKey> pKeys = polytomousKeyService.list(PolytomousKey.class, null, null, null, null);

        Iterator<PolytomousKey> pKeysItr = pKeys.iterator();

        Assert.assertEquals(pKeysItr.next().getUuid(),UUID.fromString("9d8bf4f6-a70a-4b80-8556-2ccfb436ff01"));

        Assert.assertEquals(pKeysItr.next().getUuid(),UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66"));

    }

    @Test

    //@DataSet("PolytomousKeyTest.readPolytmousKeyData.xml")

    public void readPolytmousKeyData() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        Set<Taxon> taxonomicScope = pKey.getTaxonomicScope();

        Iterator<Taxon> tsItr = taxonomicScope.iterator();

        Taxon taxon = tsItr.next();

        Assert.assertEquals("Achillea sec. Cyprus", taxon.getTitleCache());

        Assert.assertEquals(tsItr.hasNext(), false);

        List<Credit> credits = pKey.getCredits();

        AgentBase agent = credits.get(0).getAgent();

        Assert.assertEquals(agent.getId(),4809);

        Assert.assertEquals(agent.getTitleCache(),"R. A. Graham");

        Assert.assertEquals(credits.get(0).getText(),"Credits Text Test");

        Set<Extension> exts = pKey.getExtensions();

        Iterator<Extension> extItr = exts.iterator();

        Extension ext = extItr.next();

        Assert.assertEquals(ext.getValue(), "http://test.com");

        Set<Rights> rights = pKey.getRights();

        Iterator<Rights> rightsItr = rights.iterator();

        Rights right = rightsItr.next();

        Assert.assertEquals(right.getText(),"Rights Text Test");

        Set<IdentifiableSource> sources = pKey.getSources();

        Iterator<IdentifiableSource> sourcesItr = sources.iterator();

        IdentifiableSource source = sourcesItr.next();

        Assert.assertEquals(source.getId(), 23710);

        source = sourcesItr.next();

        Assert.assertEquals(source.getId(), 23711);

        // TO DO : Added tests for Annotations , Markers

    }

    @Test

    public void readPolytomousKeyDataFromNodes() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode rootNode = pKey.getRoot();

        Assert.assertEquals(rootNode.getId(), 2750);

        Assert.assertEquals(rootNode.getChildAt(0).getId(), 2751);

        Assert.assertEquals(rootNode.getChildAt(0).getParent().getId(), rootNode.getId());

        Assert.assertEquals(rootNode.getKey().getId(), pKey.getId());

        Integer sortIndex = (Integer)getFieldValueViaReflection(rootNode.getChildAt(0), "sortIndex");

        Assert.assertEquals(sortIndex, new Integer(0));

        String statement = "Capitula without ligulate ray-florets; leaves entire or subentire";

        Assert.assertEquals(rootNode.getChildAt(0).getStatement().getLabelText(english), statement);

        Assert.assertEquals(rootNode.getChildAt(1).getId(), 2753);

        Assert.assertEquals(rootNode.getChildAt(1).getParent().getId(), rootNode.getId());

        Assert.assertEquals(rootNode.getChildAt(1).getKey().getId(), pKey.getId());

        sortIndex = (Integer)getFieldValueViaReflection(rootNode.getChildAt(1), "sortIndex");

        Assert.assertEquals(sortIndex, new Integer(1));

        statement = "Capitula with ligulate ray-florets; leaves pinnatisect";

        Assert.assertEquals(rootNode.getChildAt(1).getStatement().getLabelText(english), statement);

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getId(), 2754);

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getParent().getId(), rootNode.getChildAt(1).getId());

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getKey().getId(), pKey.getId());

        sortIndex = (Integer)getFieldValueViaReflection(rootNode.getChildAt(1).getChildAt(0), "sortIndex");

        Assert.assertEquals(sortIndex, new Integer(0));

        statement = "Ray-florets yellow";

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getStatement().getLabelText(english), statement);

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getChildAt(0).getTaxon().getTitleCache(), "Achillea arabica Kotschy sec. Cyprus");

    }

    @Test

    public void savePolytomousKeyNodeData() {

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        String newQuestion = "New Question";

        String newStatement = "New Statement";

        Assert.assertEquals("Question 1",pkeynode.getQuestion().getLabel().get(english).getText());

        for(PolytomousKeyNode node : pkeynode.getChildren()) {

            node.setQuestion(null);

            node.setStatement(null);

        }

        //FIXME:Remoting Add tests for feature after fixing problem

        //Feature feature = pkeynode.getFeature();

        //Assert.assertEquals(feature.getTitleCache(),"Systematics");

        //pkeynode.setFeature(null);

        Assert.assertEquals(pkeynode.getChildAt(0).getModifyingText().get(english).getText(),"Modifying Text 1a");

        String modifyingText = "Modifying Text 1a updated";

        //pkeynode.getChildAt(0).putModifyingText(english, modifyingText);

        Assert.assertEquals(pkeynode.getChildAt(0).getSubkey().getId(),751);

        Assert.assertEquals("Asphodeline", pkeynode.getChildAt(0).getSubkey().getTitleCache());

        Assert.assertNull(pkeynode.getChildAt(1).getTaxon());

        Taxon taxon = CdmBase.deproxy(taxonService.find(taxon1Uuid),Taxon.class);

        pkeynode.getChildAt(1).setTaxon(taxon);

        EntityCacherDebugResult debugResult = new EntityCacherDebugResult(cacher,  Arrays.asList(pkey));

        polytomousKeyService.merge(pkey);

        pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        sessionOwner = new MockSessionOwner();

        pkeynode = pkey.getRoot();

        for(PolytomousKeyNode node : pkeynode.getChildren()) {

            Assert.assertNull(node.getQuestion());

            node.setQuestion(KeyStatement.NewInstance(english,newQuestion));

            Assert.assertNull(node.getStatement());

            node.setStatement(KeyStatement.NewInstance(english,newStatement));

        }

        Assert.assertEquals(pkeynode.getChildAt(1).getTaxon(), taxon);

        polytomousKeyService.merge(pkey);

        pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        sessionOwner = new MockSessionOwner();

        pkeynode = pkey.getRoot();

        for(PolytomousKeyNode node : pkeynode.getChildren()) {

            Assert.assertNotNull(node.getQuestion());

            Map<Language, LanguageString> label = node.getQuestion().getLabel();

            Assert.assertEquals(newQuestion, label.get(english).getText());

            Assert.assertNotNull(node.getStatement());

            Assert.assertEquals(newStatement, node.getStatement().getLabel(english).getText());

        }

        //Assert.assertEquals(pkeynode.getFeature().getId(), feature.getId());

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameSubKey() {

        ICdmEntitySessionEnabled sessionOwner = new MockSessionOwner();

        cdmEntitySessionManager.bind(sessionOwner);

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        PolytomousKey subkey1 = CdmBase.deproxy(pkeynode.getChildAt(0).getSubkey(), PolytomousKey.class);

        String subkey1title = subkey1.getTitleCache();

        subkey1.setTitleCache(subkey1title + "test", true);

        PolytomousKey subkey2 = CdmBase.deproxy(pkeynode.getChildAt(1).getChildAt(0).getSubkey(), PolytomousKey.class);

        String subkey2title = subkey2.getTitleCache();

        subkey2.setTitleCache(subkey2title + "test", true);

        Assert.assertSame(subkey1, subkey2);

        polytomousKeyService.merge(pkey);

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameSubKeyUsingService() {

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        PersistentCollection children = (PersistentCollection) pkeynode.getChildren();

        PolytomousKeyNode childNode0 = (PolytomousKeyNode)commonService.get(pkeynode.getUuid(), "children", 0);

        PolytomousKey subkey1 = CdmBase.deproxy(childNode0.getSubkey(),PolytomousKey.class);

        String subkey1title = subkey1.getTitleCache();

        subkey1.setTitleCache(subkey1title + "test", true);

        PolytomousKeyNode childNode1 = (PolytomousKeyNode)commonService.get(pkeynode.getUuid(), "children", 1);

        PolytomousKey subkey2 = CdmBase.deproxy(childNode1.getSubkey(),PolytomousKey.class);

        String subkey2title = subkey2.getTitleCache();

        subkey2.setTitleCache(subkey2title + "test", true);

        Assert.assertNotSame(childNode0, childNode1);

        Assert.assertSame(subkey1, subkey2);

        polytomousKeyService.merge(pkey);

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameLanguageInLabel() {

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        Map<Language, LanguageString> label1 = pkeynode.getQuestion().getLabel();

        label1.size();

        Map<Language, LanguageString> label2 = pkeynode.getChildAt(0).getStatement().getLabel();

        label2.size();

        polytomousKeyService.merge(pkey);

    }

    @Test

    public void deleteSubKeyInPolytomousSubKeyWithoutInitializing() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode rootNode = pKey.getRoot();

        PolytomousKeyNode child = rootNode.getChildAt(0);

        PolytomousKey subKey = child.getSubkey();

        polytomousKeyService.delete(subKey);

        // since subKey was not initialized before the delete, an attempt

        // to initialize it after will lead to an NPE

        try {

            PolytomousKeyNode subKeyRootNode = subKey.getRoot();

            Assert.fail("A NullPointerException indicating null root node should be thrown here");

        } catch(NullPointerException npe) {

        }

        // retrieving subkey shows its null

        subKey = CdmBase.deproxy(polytomousKeyService.find(subKeyUuid),PolytomousKey.class);

        Assert.assertNull(subKey);

        pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        rootNode = pKey.getRoot();

        child = rootNode.getChildAt(0);

        subKey = child.getSubkey();

        // subkey will not be null, because the delete functionality of the subkey

        // does not currently delete it from a polytomous key node

        Assert.assertNotNull(subKey);

        // after reloading the object graph, accessing subKey should throw a null pointer exception

        try {

            PolytomousKeyNode subKeyRootNode = subKey.getRoot();

            Assert.fail("A NullPointerException indicating null root node should be thrown here");

        } catch(NullPointerException npe) {

        }

    }

    @Test

    public void deleteSubKeyInPolytomousNode() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode rootNode = pKey.getRoot();

        List<PolytomousKeyNode> children = rootNode.getChildren();

        PolytomousKeyNode child = rootNode.getChildAt(0);

        polytomousKeyNodeService.delete(child.getUuid(), true);

        pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        rootNode = pKey.getRoot();

        children = rootNode.getChildren();

        Assert.assertFalse(children.contains(child));

    }

    @Test

    public void deleteSubKeyInPolytomousSubKeyAfterInitializing() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode rootNode = pKey.getRoot();

        PolytomousKeyNode child = rootNode.getChildAt(0);

        PolytomousKey subKey = child.getSubkey();

        // this call initializes the subkey

        subKey.getRoot();

        polytomousKeyService.delete(subKey);

        // since subKey was initialized before the delete, it will be

        // accesible even after the delete. This behaviour is similar

        // to hibernate session delete where the deleted object is

        // made transient, but not deleted from the object graph

        PolytomousKeyNode subKeyRootNode = subKey.getRoot();

        Assert.assertNotNull(subKey);

    }

}

// $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.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.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.operations.BaseOperationTest;

/**

 * @author cmathew

 * @date 3 Feb 2015

 *

 */

@DataSet

public class TaxonNameEditorTest extends BaseOperationTest {

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

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

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

    }

}

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

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.config.TaxonDeletionConfigurator;

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

import eu.etaxonomy.cdm.api.service.config.TaxonNodeDeletionConfigurator.ChildHandling;

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.navigation.navigator.operation.RemotingChangeAcceptedTaxonToSynonymOperation;

import eu.etaxonomy.taxeditor.navigation.navigator.operation.RemotingDeleteTaxonNodeOperation;

import eu.etaxonomy.taxeditor.navigation.navigator.operation.RemotingMoveFactualDataOperation;

import eu.etaxonomy.taxeditor.navigation.navigator.operation.RemotingMoveTaxonOperation;

import eu.etaxonomy.taxeditor.operations.BaseOperationTest;

/**

 * @author cmathew

 * @date 9 Mar 2015

 *

 */

@DataSet

public class TaxonNavigatorTest extends BaseOperationTest {

    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 testChangeAcceptedTaxonToSynonym() throws ExecutionException {

        UUID oldTaxonNodeNodeUuid = UUID.fromString("b85b5b78-6760-409f-ac91-bb89e95ff2a1");

        UUID newAcceptedTaxonNodeUuid = UUID.fromString("6ad8e9e2-f5f6-41ad-aa30-f62a903650db");

        TaxonNode oldTaxonNode = taxonNodeService.load(oldTaxonNodeNodeUuid);

        TaxonNameBase name = oldTaxonNode.getTaxon().getName();

        TaxonNode newAcceptedTaxonNode = taxonNodeService.load(newAcceptedTaxonNodeUuid);

        int countTargetSynonyms = newAcceptedTaxonNode.getTaxon().getSynonyms().size();

        sessionOwner.addExpectedUpdatedObject(oldTaxonNode.getParent());

        sessionOwner.addExpectedUpdatedObject(newAcceptedTaxonNode);

        operation =  new RemotingChangeAcceptedTaxonToSynonymOperation(sessionOwner,

                false,

                oldTaxonNode.getUuid(),

                newAcceptedTaxonNode.getUuid());

        operation.execute(monitor, info);

        newAcceptedTaxonNode = taxonNodeService.load(newAcceptedTaxonNodeUuid);

        oldTaxonNode = taxonNodeService.load(oldTaxonNodeNodeUuid);

        Assert.assertNull(oldTaxonNode);

        Assert.assertEquals(countTargetSynonyms + 1,newAcceptedTaxonNode.getTaxon().getSynonyms().size());

        Assert.assertEquals(name, newAcceptedTaxonNode.getTaxon().getSynonyms().iterator().next().getName());

    }

    @Test

    public void testMoveTaxon() throws ExecutionException {

        UUID taxonNodeToMoveUuid = UUID.fromString("b8439f51-6b96-445a-b401-7a836ba1cf58");

        UUID newParentTreeNodeUuid = UUID.fromString("2f05d429-632d-4230-b9cb-70299360b470");

        boolean moveToParentNode = true;

        TaxonNode taxonNodeToMove = taxonNodeService.load(taxonNodeToMoveUuid);

        TaxonNode oldParent = taxonNodeToMove.getParent();

        sessionOwner.addExpectedUpdatedObject(oldParent);

        int childCount = oldParent.getCountChildren();

        TaxonNode newParentTreeNode = taxonNodeService.load(newParentTreeNodeUuid);

        sessionOwner.addExpectedUpdatedObject(newParentTreeNode);

        operation = new RemotingMoveTaxonOperation(sessionOwner,

                false,

                taxonNodeToMove.getUuid(),

                newParentTreeNode.getUuid(),

                moveToParentNode);

        operation.execute(monitor, info);

        Assert.assertEquals(childCount-1, oldParent.getCountChildren());

        Assert.assertTrue(!oldParent.getChildNodes().contains(taxonNodeToMove));

        Assert.assertTrue(newParentTreeNode.getChildNodes().contains(taxonNodeToMove));

    }

    @Test

    public void testMoveFactualData() throws ExecutionException {

        UUID sourceTaxonUuid = UUID.fromString("e40854d7-143f-4054-b229-6ed4cedb4bff");

        UUID targetTaxonUuid = UUID.fromString("b8402dc4-5050-4882-a147-01b71e0e47d6");

        Taxon sourceTaxon = CdmBase.deproxy(taxonService.load(sourceTaxonUuid), Taxon.class);

        Set<TaxonDescription> sourceDescriptions = new HashSet(sourceTaxon.getDescriptions());

        sessionOwner.addExpectedUpdatedObject(sourceTaxon);

        Taxon targetTaxon = CdmBase.deproxy(taxonService.load(targetTaxonUuid), Taxon.class);

        int countTargetDescriptions = targetTaxon.getDescriptions().size();

        sessionOwner.addExpectedUpdatedObject(targetTaxon);

        operation = new RemotingMoveFactualDataOperation(sessionOwner,

                false,

                sourceTaxonUuid,

                targetTaxonUuid);

        operation.execute(monitor, info);

        Assert.assertEquals(0, sourceTaxon.getDescriptions().size());

        Assert.assertEquals(sourceDescriptions.size() + countTargetDescriptions, targetTaxon.getDescriptions().size());

        Assert.assertTrue(targetTaxon.getDescriptions().containsAll(sourceDescriptions));

    }

    @Test

    public void testDeleteTaxonNodeWithDeleteChildren() throws ExecutionException {

        UUID taxonNodeUuid = UUID.fromString("2f05d429-632d-4230-b9cb-70299360b470");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        List<TaxonNode> childNodes = taxonNode.getChildNodes();

        List<UUID> childNodeUuids = new ArrayList<UUID>();

        for(TaxonNode childNode : childNodes) {

            childNodeUuids.add(childNode.getUuid());

        }

        Assert.assertTrue(taxonNode.getCountChildren() > 0);

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

        nodes.add(taxonNode);

        TaxonNodeDeletionConfigurator configNodes = new TaxonNodeDeletionConfigurator();

        configNodes.setChildHandling(ChildHandling.DELETE);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        config.setTaxonNodeConfig(configNodes);

        sessionOwner.addExpectedUpdatedObject(taxonNode.getParent());

        operation = new RemotingDeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                config);

        operation.execute(monitor, info);

        TaxonNode reloadedNode = taxonNodeService.load(taxonNode.getUuid());

        Assert.assertNull(reloadedNode);

        for(UUID childNodeUuid : childNodeUuids) {

            TaxonNode reloadedChildNode = taxonNodeService.load(childNodeUuid);

            Assert.assertNull(reloadedChildNode);

        }

    }

    @Ignore // waiting for #5019 to be fixed

    @Test

    public void testDeleteTaxonNodes() throws ExecutionException {

        UUID taxonNode1Uuid = UUID.fromString("99f03b56-67cd-4e01-9ceb-2362d48f9d07");

        UUID taxonNode2Uuid = UUID.fromString("91698cec-615f-4472-9002-feda1a6acded");

        UUID taxonNode3Uuid = UUID.fromString("4fe03763-b966-4361-8334-352f6f777588");

        TaxonNode taxonNode1 = taxonNodeService.load(taxonNode1Uuid);

        TaxonNode taxonNode2 = taxonNodeService.load(taxonNode2Uuid);

        TaxonNode taxonNode3 = taxonNodeService.load(taxonNode3Uuid);

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

        nodes.add(taxonNode1);

        nodes.add(taxonNode2);

        nodes.add(taxonNode3);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        sessionOwner.addExpectedUpdatedObject(taxonNode1.getParent());

        sessionOwner.addExpectedUpdatedObject(taxonNode2.getParent());

        sessionOwner.addExpectedUpdatedObject(taxonNode3.getParent());

        operation = new RemotingDeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                config);

        operation.execute(monitor, info);

        TaxonNode reloadedNode1 = taxonNodeService.load(taxonNode1.getUuid());

        TaxonNode reloadedNode2 = taxonNodeService.load(taxonNode2.getUuid());

        TaxonNode reloadedNode3 = taxonNodeService.load(taxonNode3.getUuid());

        Assert.assertNull(reloadedNode1);

        Assert.assertNull(reloadedNode2);

        Assert.assertNull(reloadedNode3);

    }

    @Test

    public void testDeleteTaxonNodeWithMovingChildrenToParentNode() throws ExecutionException {

        UUID taxonNodeUuid = UUID.fromString("2f05d429-632d-4230-b9cb-70299360b470");

        TaxonNode taxonNode = taxonNodeService.load(taxonNodeUuid);

        TaxonNode parentTaxonNode = taxonNode.getParent();

        List<TaxonNode> childNodes = taxonNode.getChildNodes();

        List<UUID> childNodeUuids = new ArrayList<UUID>();

        for(TaxonNode childNode : childNodes) {

            childNodeUuids.add(childNode.getUuid());

        }

        Assert.assertTrue(taxonNode.getCountChildren() > 0);

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

        nodes.add(taxonNode);

        TaxonNodeDeletionConfigurator configNodes = new TaxonNodeDeletionConfigurator();

        configNodes.setChildHandling(ChildHandling.MOVE_TO_PARENT);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        config.setTaxonNodeConfig(configNodes);

        sessionOwner.addExpectedUpdatedObject(taxonNode.getParent());

        operation = new RemotingDeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                config);

        operation.execute(monitor, info);

        TaxonNode reloadedNode = taxonNodeService.load(taxonNode.getUuid());

        Assert.assertNull(reloadedNode);

        List<TaxonNode> parentChildNodes = parentTaxonNode.getChildNodes();

        List<UUID> parentChildNodeUuids = new ArrayList<UUID>();

        for(TaxonNode parentChildNode : parentChildNodes) {

            parentChildNodeUuids.add(parentChildNode.getUuid());

        }

        parentChildNodeUuids.containsAll(childNodeUuids);

    }

    @Test

    @DataSet("TaxonNavigatorTest.testDeleteClassificationWithDeleteChildren.xml")

    public void testDeleteClassificationWithDeleteChildren() throws ExecutionException {

        UUID classificationUuid = UUID.fromString("0c2b5d25-7b15-4401-8b51-dd4be0ee5cab");

        Classification classification = classificationService.load(classificationUuid);

        TaxonNode rootNode = classification.getRootNode();

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

        nodes.add(classification);

        TaxonNodeDeletionConfigurator configNodes = new TaxonNodeDeletionConfigurator();

        configNodes.setChildHandling(ChildHandling.DELETE);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        config.setTaxonNodeConfig(configNodes);

        operation = new RemotingDeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                config);

        operation.execute(monitor, info);

        Classification reloadedClassification = classificationService.load(classification.getUuid());

        Assert.assertNull(reloadedClassification);

        TaxonNode reloadedRootNode = taxonNodeService.load(rootNode.getUuid());

        Assert.assertNull(reloadedRootNode);

    }

}