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.taxeditor.session;

import java.util.ArrayList;

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

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

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

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.common.TermType;

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

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;

/**

 * @author cmathew

 * @date 7 Oct 2014

 *

 */

@DataSet

public class CdmEntitySessionAwareTest extends RemotingSessionAwareTest {

    private static final Logger logger = Logger.getLogger(CdmEntitySessionAwareTest.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();

    IVocabularyService vocabularyService = getRemoteApplicationController().getVocabularyService();

    ITermService termService = getRemoteApplicationController().getTermService();

    //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(Language.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(Language.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(Language.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(Language.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(Language.ENGLISH()).getText(),"Modifying Text 1a");

        String modifyingText = "Modifying Text 1a updated";

        //pkeynode.getChildAt(0).putModifyingText(Language.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);

        polytomousKeyService.merge(pkey);

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

        pkeynode = pkey.getRoot();

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

            Assert.assertNull(node.getQuestion());

            node.setQuestion(KeyStatement.NewInstance(Language.ENGLISH(),newQuestion));

            Assert.assertNull(node.getStatement());

            node.setStatement(KeyStatement.NewInstance(Language.ENGLISH(),newStatement));

        }

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

        polytomousKeyService.merge(pkey);

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

        pkeynode = pkey.getRoot();

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

            Assert.assertNotNull(node.getQuestion());

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

            Assert.assertEquals(newQuestion, label.get(Language.ENGLISH()).getText());

            Assert.assertNotNull(node.getStatement());

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

        }

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

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameSubKey() {

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

    }

    @Test

    public void saveNewTermVocabulary() {

        TermVocabulary termVocabulary =

                TermVocabulary.NewInstance(TermType.Feature,

                        null,

                        "Untitled",

                        null,

                        null);

        try {

            List<TermVocabulary<DefinedTermBase>> vocabularies = vocabularyService.findByTermType(TermType.Feature);

            for(TermVocabulary vocab : vocabularies) {

                vocab.getTermsOrderedByLabels(Language.ENGLISH());

            }

            termVocabulary = vocabularyService.merge(termVocabulary);

            vocabularies.add(termVocabulary);

            termVocabulary.setLabel("Test");

            vocabularyService.merge(new ArrayList<TermVocabulary>(vocabularies));

        } finally {

            vocabularyService.delete(termVocabulary);

        }

    }

    @Test

    public void saveNewTerm() {

        UUID vocNameFeatureUuid = UUID.fromString("fa7ca3eef-4092-49e1-beec-ed5096193e5e");

        UUID vocFeatureUuid = UUID.fromString("b187d555-f06f-4d65-9e53-da7c93f8eaa8");

        DefinedTermBase newTerm = TermType.Feature.getEmptyDefinedTermBase();

        newTerm.setLabel("CreateTest");

        try {

            Assert.assertNotNull(newTerm);

            TermVocabulary vocNameFeature = vocabularyService.find(vocNameFeatureUuid);

            TermVocabulary vocFeature = vocabularyService.find(vocFeatureUuid);

            List<TermVocabulary> vocs = new ArrayList<TermVocabulary>();

            vocs.add(vocNameFeature);

            vocs.add(vocFeature);

            vocNameFeature.addTerm(newTerm);

            vocs = vocabularyService.merge(vocs);

            for(TermVocabulary voc : vocs) {

                if(voc.getUuid().equals(vocNameFeatureUuid)) {

                    vocNameFeature = voc;

                }

            }

            Assert.assertTrue(vocNameFeature.getTerms().contains(newTerm));

            for(Object obj : vocNameFeature.getTerms()) {

                DefinedTermBase dtb = (DefinedTermBase)obj;

                if("CreateTest".equals(dtb.getLabel())) {

                    newTerm = dtb;

                    Assert.assertNotNull(dtb.getCreatedBy());

                    Assert.assertNotNull(dtb.getCreated());

                }

            }

            newTerm.setLabel("UpdateTest");

            newTerm = termService.merge(newTerm);

            Assert.assertNotNull(newTerm.getUpdatedBy());

            Assert.assertNotNull(newTerm.getUpdated());

        } finally {

            termService.delete(newTerm.getUuid());

        }

    }

}