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.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.NodeDeletionConfigurator.ChildHandling;

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;

import eu.etaxonomy.taxeditor.navigation.navigator.e4.TreeNodeDropAdapterE4.MovingType;

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

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

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

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

/**

 * @author cmathew

 * @date 9 Mar 2015

 */

@DataSet

public class TaxonNavigatorTest 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 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);

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

        TaxonNode newAcceptedTaxonNode = taxonNodeService.load(newAcceptedTaxonNodeUuid);

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

        sessionOwner.addExpectedUpdatedObject(oldTaxonNode.getParent());

        sessionOwner.addExpectedUpdatedObject(newAcceptedTaxonNode);

        operation =  new ChangeAcceptedTaxonToSynonymOperation(sessionOwner,

                false,

                oldTaxonNode.getUuid(),

                newAcceptedTaxonNode.getUuid(), null, null, true);

        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

    @Ignore

    public void testMoveTaxon() throws ExecutionException {

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

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

        MovingType moveToParentNode = MovingType.CHILD;

        TaxonNode taxonNodeToMove = taxonNodeService.load(taxonNodeToMoveUuid);

        TaxonNode oldParent = taxonNodeToMove.getParent();

        Set<UUID>uuids = new HashSet<>();

        uuids.add(taxonNodeToMoveUuid);

       // sessionOwner.addExpectedUpdatedObject(oldParent);

        int childCount = oldParent.getCountChildren();

        TaxonNode newParentTreeNode = taxonNodeService.load(newParentTreeNodeUuid);

       // sessionOwner.addExpectedUpdatedObject(newParentTreeNode);

        operation = new MoveTaxonOperation(sessionOwner,

                false,

                uuids,

                newParentTreeNode.getUuid(),

                moveToParentNode);

        operation.execute(monitor, info);

        //TODO: fix this, because move taxon is now a longrunning task

//        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 MoveFactualDataOperation(sessionOwner,

                false,

                sourceTaxonUuid,

                targetTaxonUuid, true);

        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<TaxonNodeDto> nodes = new HashSet<>();

        nodes.add(new TaxonNodeDto(taxonNode));

        TaxonNodeDeletionConfigurator configNodes = new TaxonNodeDeletionConfigurator();

        configNodes.setChildHandling(ChildHandling.DELETE);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        config.setTaxonNodeConfig(configNodes);

        sessionOwner.addExpectedUpdatedObject(taxonNode.getParent());

        operation = new DeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                null,

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

        }

    }

    @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<TaxonNodeDto> nodes = new HashSet<>();

        nodes.add(new TaxonNodeDto(taxonNode1));

        nodes.add(new TaxonNodeDto(taxonNode2));

        nodes.add(new TaxonNodeDto(taxonNode3));

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        sessionOwner.addExpectedUpdatedObject(taxonNode1.getParent());

        sessionOwner.addExpectedUpdatedObject(taxonNode2.getParent());

        sessionOwner.addExpectedUpdatedObject(taxonNode3.getParent());

        operation = new DeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                null,

                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<TaxonNodeDto> nodes = new HashSet<>();

        nodes.add(new TaxonNodeDto(taxonNode));

        TaxonNodeDeletionConfigurator configNodes = new TaxonNodeDeletionConfigurator();

        configNodes.setChildHandling(ChildHandling.MOVE_TO_PARENT);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        config.setTaxonNodeConfig(configNodes);

        sessionOwner.addExpectedUpdatedObject(taxonNode.getParent());

        operation = new DeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                null,

                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<TaxonNodeDto> nodes = new HashSet<>();

        nodes.add(new TaxonNodeDto(classification.getRootNode()));

        TaxonNodeDeletionConfigurator configNodes = new TaxonNodeDeletionConfigurator();

        configNodes.setChildHandling(ChildHandling.DELETE);

        TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();

        config.setTaxonNodeConfig(configNodes);

        operation = new DeleteTaxonNodeOperation(sessionOwner,

                false,

                nodes,

                null,

                config);

        operation.execute(monitor, info);

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

        Assert.assertNull(reloadedClassification);

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

        Assert.assertNull(reloadedRootNode);

    }

}