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

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import net.sf.ehcache.Cache;

import net.sf.ehcache.Element;

import net.sf.ehcache.config.CacheConfiguration;

import net.sf.ehcache.config.SizeOfPolicyConfiguration;

import net.sf.ehcache.statistics.LiveCacheStatistics;

import net.sf.ehcache.store.MemoryStoreEvictionPolicy;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.api.cache.CdmServiceCacher;

import eu.etaxonomy.cdm.model.ICdmCacher;

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

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;

/**

 *

 * This cache guarantees that

 *  - all objects put will be ancestors of CdmBase

 *  - all CdmBase objects in the cache will be already de-proxied

 *  - after any CdmBase object is put in the cache,

 *  all non-null / non-proxy CdmBase objects in the sub-graph

 *  will also be present in the cache.

 *

 * @author cmathew

 * @date 14 Oct 2014

 *

 */

public class CdmTransientEntityCacher implements ICdmCacher {

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

    private final ICdmEntitySessionManager cdmEntitySessionManager;

    private static CdmServiceCacher cdmServiceCacher;

    private final String cacheId;

    private final Cache cache;

    private final CacheLoader cacheLoader;

    public static enum CollectionType {

        SET,

        LIST,

        MAP;

        @Override

        public String toString() {

            return this.name().toLowerCase();

        }

    }

    public CdmTransientEntityCacher(String cacheId, ICdmEntitySessionManager cdmEntitySessionManager) {

        this.cacheId = cacheId;

        cache = new Cache(getEntityCacheConfiguration(cacheId));

        CdmRemoteCacheManager.getInstance().getDefaultCacheManager().addCache(cache);

        cacheLoader = new CacheLoader(this);

        this.cdmEntitySessionManager = cdmEntitySessionManager;

    }

    public CdmTransientEntityCacher(Object obj, ICdmEntitySessionManager cdmEntitySessionManager) {

        this(obj.getClass().getName() +  String.valueOf(obj.hashCode()), cdmEntitySessionManager);

    }

    /**

     * Returns the default cache configuration.

     *

     * @return

     */

    private CacheConfiguration getEntityCacheConfiguration(String cacheId) {

        SizeOfPolicyConfiguration sizeOfConfig = new SizeOfPolicyConfiguration();

        sizeOfConfig.setMaxDepth(10000);

        sizeOfConfig.setMaxDepthExceededBehavior("abort");

        // For a better understanding on how to size caches, refer to

        // http://ehcache.org/documentation/configuration/cache-size

        return new CacheConfiguration(cacheId, 500)

        .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LFU)

        //.eternal(true);

        // default ttl and tti set to 2 hours

        .timeToLiveSeconds(60*60*2)

        .timeToIdleSeconds(60*60*2)

        .statistics(true)

        .sizeOfPolicy(sizeOfConfig);

    }

    public static void setDefaultCacher(CdmServiceCacher css) {

        cdmServiceCacher = css;

    }

    public LiveCacheStatistics getCacheStatistics() {

        return cache.getLiveCacheStatistics();

    }

    /**

     * Returns the cache corresponding to the cache id

     *

     * @param cacheId

     * @return

     */

    private Cache getCache() {

        return  CdmRemoteCacheManager.getInstance().getDefaultCacheManager().getCache(cacheId);

    }

    public <T extends Object> T load(T obj, boolean recursive) {

        return cacheLoader.load(obj, recursive);

    }

    public <T extends Object> Map<T,T> load(Map<T,T> map, boolean recursive){

        return cacheLoader.load(map, recursive);

    }

    public <T extends Object> Collection<T> load(Collection<T> collection, boolean recursive){

        return cacheLoader.load(collection, recursive);

    }

    public CdmBase load(CdmBase cdmEntity, boolean recursive) {

        return cacheLoader.load(cdmEntity, recursive);

    }

    public CdmModelFieldPropertyFromClass getFromCdmlibModelCache(String className) {

        return cacheLoader.getFromCdmlibModelCache(className);

    }

    @Override

    public void put(CdmBase cdmEntity) {

        CdmEntityCacheKey id = new CdmEntityCacheKey(cdmEntity);

        Element cachedCdmEntityElement = cdmServiceCacher.getCacheElement(cdmEntity.getUuid());

        if(cachedCdmEntityElement != null) {

            logger.info("Cdm Entity with id : " + cdmEntity.getId() + " already exists in permanent cache. Ignoring put.");

            return;

        }

        getCache().put(new Element(id, cdmEntity));

    }

    private Element getCacheElement(CdmEntityCacheKey key) {

        return getCache().get(key);

    }

    public CdmBase getFromCache(CdmEntityCacheKey id) {

        Element e = getCacheElement(id);

        if (e == null) {

            return null;

        } else {

            return (CdmBase) e.getObjectValue();

        }

    }

    public CdmBase getFromCache(Class<? extends CdmBase> clazz, int id) {

        CdmEntityCacheKey cacheId = generateKey(clazz,id);

        return getFromCache(cacheId);

    }

    @Override

    public CdmBase getFromCache(CdmBase cdmBase) {

        CdmEntityCacheKey cacheId = generateKey(cdmBase);

        // first try this cache

        CdmBase  cachedCdmEntity = getFromCache(cacheId);

        if(cachedCdmEntity == null) {

            // ... then try the permanent cache

            cachedCdmEntity = cdmServiceCacher.load(cdmBase);

        }

        return cachedCdmEntity;

    }

    public CdmBase getFromCache(CdmBase cdmBase, Class<? extends CdmBase> clazz) {

        cdmBase = CdmBase.deproxy(cdmBase, clazz);

        return getFromCache(cdmBase);

    }

    public List<CdmBase> getAllEntities() {

        List<CdmBase> entities = new ArrayList<CdmBase>();

        Map<String, CdmBase> elementsMap = getCache().getAllWithLoader(getCache().getKeys(), null);

        for (Map.Entry<String, CdmBase> entry : elementsMap.entrySet()) {

            entities.add(entry.getValue());

        }

        return entities;

    }

    public boolean exists(CdmEntityCacheKey key) {

        return (getCacheElement(key) != null);

    }

    public boolean existsAndIsNotNull(CdmEntityCacheKey id) {

        return getFromCache(id) != null;

    }

    public void clear() {

        cache.removeAll();

    }

    public void dispose() {

        cache.removeAll();

        cache.flush();

        CdmRemoteCacheManager.getInstance().getDefaultCacheManager().removeCache(cacheId);

    }

    public static CdmEntityCacheKey generateKey(Class<? extends CdmBase> clazz, int id) {

        return new CdmEntityCacheKey(clazz, id);

    }

    public static CdmEntityCacheKey generateKey(CdmBase cdmBase) {

        Class<? extends CdmBase> entityClass = cdmBase.getClass();

        int id = cdmBase.getId();

        return new CdmEntityCacheKey(entityClass, id);

    }

}