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.api.cache;

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

import org.apache.log4j.Logger;

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

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.taxeditor.httpinvoker.BaseRemotingTest;

import eu.etaxonomy.taxeditor.httpinvoker.CDMServer;

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 7 Oct 2014

 *

 */

@DataSet

public class CdmClientCachingTest extends BaseRemotingTest {

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

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

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

    private final UUID polytomousKeyNodeUuid1 = UUID.fromString("75e4c924-ff58-4ee7-a59d-fd9173517d08");

    private final UUID polytomousKeyNodeUuid2 = UUID.fromString("b775c027-13c0-4b87-8aa9-712faeaafbdc");

    private final IPolytomousKeyService polytomousKeyService = getRemoteApplicationController().getPolytomousKeyService();

    private final IPolytomousKeyNodeService polytomousKeyNodeService = getRemoteApplicationController().getPolytomousKeyNodeService();

    private final ICommonService commonService = getRemoteApplicationController().getCommonService();

    private final ITaxonService taxonService = getRemoteApplicationController().getTaxonService();

	private CdmTransientEntityCacher cacher;

    private ICdmEntitySession cdmEntitySession;

    private static final List<String> PKEY_DEPTH1_INIT_STRATEGY = Arrays.asList(new String[] {

			});

    private static final List<String> PKEY_DEPTH2_INIT_STRATEGY = Arrays.asList(new String[] {

    		"root"});

    private static final List<String> PKEY_DEPTH3_INIT_STRATEGY = Arrays.asList(new String[] {

    		"root.statement"});

    private ICdmEntitySessionEnabled sessionOwner;

    @BeforeClass

    public static void initializePolytomousKeyTest() {

        logger.setLevel(Level.INFO);

        CDMServer.getInstance().setKeepServerRunning(true);

    }

    @Before

    public void initializeSession() {

    	sessionOwner = new MockSessionOwner();

    	cdmEntitySession = cdmEntitySessionManager.newSession(sessionOwner, true);

    	cacher = getCacher(sessionOwner);

    }

    @Test

    public void recursiveLoadSubGraphDepth1Test() {

    	// this call will load into the session cache the graph

    	// polytomous key

    	// 	|- root : polytomous key node

    	// in a recursive call

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);

        // checking to make sure the root object is in the session cache

        Assert.assertSame(pkey1.getRoot(), cacher.getFromCache(pkey1.getRoot()));

    }

    @Test

    public void recursiveLoadSubGraphDepth2Test() {

    	// this call will load into the session cache the graph

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

    	// in a recursive call

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

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

        // checking to make sure the root object is in the session cache

        Assert.assertSame(pkey.getRoot(), cacher.getFromCache(pkey.getRoot()));

        Assert.assertSame(pkey.getRoot().getStatement(), cacher.getFromCache(pkey.getRoot().getStatement()));

        Assert.assertSame(pkey.getRoot().getQuestion(), cacher.getFromCache(pkey.getRoot().getQuestion()));

    }

    /**

     * when : retrieving objects using recursive caching of object graphs with different depths

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void lazyLoadRecursiveTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

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

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

    }

    /**

     * when : retrieving objects using recursive caching of object graphs with different depths

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void differentSubGraphDepthTest1() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	// in a recursive call

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

        PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));

        Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());

        Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));

    }

    /**

     * when : retrieving objects using recursive caching of object graphs with different depths

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void differentSubGraphDepthTest2() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

        PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);

        Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));

        Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());

        Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));

    }

    /**

     * when : retrieving objects using (first) recursive load directly and (second) lazy loading in the same session

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void recursiveLoadAndLazyLoadTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

        // checking that the root is not null and

        // that it exists in the cache and

        // that both the original object and the

        // cached object are the same

        Assert.assertNotNull(pkey1.getRoot().getStatement());

        Assert.assertNotNull(cacher.getFromCache(pkey1.getRoot().getStatement()));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

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

        Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));

        Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());

        Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));

    }

    /**

     * when : retrieving objects using (first) lazy loading  and (second) recursive load directly in the same session

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void lazyLoadAndRecursiveLoadTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

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

        // lazy initialising root.statement

        KeyStatement st = CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class);

        st.getLabel();

        // checking that the root is not null and

        // that it exists in the cache and

        // that both the original object and the

        // cached object are the same

    	Assert.assertNotNull(pkey1.getRoot().getStatement());

    	Assert.assertSame(CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class),

    			cacher.getFromCache(pkey1.getRoot().getStatement(), KeyStatement.class));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

    	PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

    	Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));

    	Assert.assertSame(st, pkey2.getRoot().getStatement());

    	Assert.assertSame(cacher.getFromCache(st), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));

    }

    /**

     * when : loading an object (first) and then (second) loading a graph the object is contained in, in the same session

     * then : the object should be the same

     */

    @Test

    public void subGraphObjectLoadTest1() {

    	// this call will load into the session cache a polytomous key node object

    	PolytomousKeyNode rootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid1),PolytomousKeyNode.class);

    	Assert.assertNotNull(rootPKNode);

    	Assert.assertSame(rootPKNode, cacher.getFromCache(rootPKNode));

    	PolytomousKeyNode childOfRootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid2),PolytomousKeyNode.class);

    	Assert.assertNotNull(childOfRootPKNode);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

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

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);

    }

    /**

     * when : loading a graph (first) and then (second) loading an object contained in in the graph, in the same session

     * then : the object should be the same

     */

    @Test

    public void subGraphObjectLoadTest2() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

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

    	// this call will load into the session cache a polytomous key node object

    	PolytomousKeyNode rootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid1),PolytomousKeyNode.class);

    	Assert.assertNotNull(rootPKNode);

    	Assert.assertSame(rootPKNode, cacher.getFromCache(rootPKNode));

    	PolytomousKeyNode childOfRootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid2),PolytomousKeyNode.class);

    	Assert.assertNotNull(childOfRootPKNode);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);

    }

    /**

     * when : loading objects from a collection

     * then : the object stored in the cache should be the same

     */

    @Test

    public void subGraphCollectionLoadTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

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

    	PolytomousKeyNode childOfRootPKNode = pkey.getRoot().getChildAt(1);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);

    }

    /**

     * when : loading a non-lazy collection in a subgraph and loading the collection directly

     * then : the object stored in the cache should be the same as the object in the sub-graph collection and

     *        the object in the directly loaded collection

     */

    @Test

    public void nonLazyCollectionLoadTest() {

    	// need to find an example of this

    }

    /**

     * when : loading objects from a map

     * then : the object stored in the cache should be the same

     */

    @Test

    public void subGraphMapLoadTest() {

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

        Language hindi = Language.getLanguageFromUuid(UUID.fromString("0a1d9d1d-135d-4575-b172-669b51673c39"));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key

    	// 	|- root : polytomous key node

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

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

    	Map<Language, LanguageString> labelMap = pkey.getRoot().getStatement().getLabel();

    	Set<Language> languages = labelMap.keySet();

    	Iterator<Language> languagesItr = languages.iterator();

    	while(languagesItr.hasNext()) {

    		Language lang = languagesItr.next();

    		if(lang.equals(english)) {

    			Assert.assertSame(lang, english);

    		}

    		if(lang.equals(hindi)) {

    			Assert.assertSame(lang, hindi);

    		}

    		Assert.assertSame(lang, cacher.getFromCache(lang));

    	}

    }

    /**

     * when : loading a non-lazy map in a subgraph and loading the map directly

     * then : the object stored in the cache should be the same as the object in the sub-graph map and

     *        the object in the directly loaded map

     */

    @Test

    public void nonLazyMapLoadTest() {

    	// need to find an example of this

    }

}