import org.apache.log4j.Logger;
import org.hibernate.exception.ExceptionUtils;

import net.sf.ehcache.CacheException;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.constructs.blocking.SelfPopulatingCache;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.constructs.blocking.CacheEntryFactory;
import net.sf.ehcache.event.CacheEventListener;

/**
 * SelfPopulatingAgedCache is a SelfPopulatingCache
 * which means it uses a CacheEntryFactory to create missing elements
 * and return them from get.  It also inherits the ability to block
 * other attempts to get the same key while a load is in progress with
 * an upper bound timeout (which does not apply to the client that first
 * tries to load the key).  If you want to keep the cache fresh with
 * a background thread and have the same upper bound for all calls,
 * look into also using an ehcache Loader with this.
 *
 * This class adds a add way to set it's timeout in the constructor,
 * and also tests for expired elements and reloads them transparently.
 *
 * ehcache.xml can only setup the basic cache properties (age till timeout
 * and so forth), so to use this decorated cache, install it like this:
 *
 * MyImplConstructor or similar init() method {
 *  Ehcache c = CacheManager.getInstance().getEhcache("com.netjets.ThingCache");
 *  if (!(c instanceof SelfPopulatingAgedCache)) {
 *      c = new SelfPopulatingAgedCache(c, categoryGetter, 5000);
 *  }
 *
 *  All this make final usage a one-liner:
 *
 *  Thing getThing(Object key) {
 *    return (Thing) CacheManager.getInstance().getEhcache("com.netjets.ThingCache")
 *      .get(key).getValue();
 *
 * @author pinkham
 */

public class SelfPopulatingAgedCache extends SelfPopulatingCache {

    static final Logger logger = Logger.getLogger(SelfPopulatingAgedCache.class);

    public SelfPopulatingAgedCache(Ehcache c, CacheEntryFactory ef, int timeout) {
        // super sets factory to this wrapper
        super(c, new ExceptionEatingCacheEntryFactoryWrapper(ef, "Credential token expired"));
        setTimeoutMillis(timeout);
        CacheManager.getInstance().replaceCacheWithDecoratedCache(c, this);
        // cache factory wrapper is also a listener but we need to register it
        getCacheEventNotificationService().registerListener((CacheEventListener)factory);
    }

    @Override
    public Element get(Object key) {
        try {
            return super.get(key);  // decorated base cache handles expiration
        } catch (CacheException e) {
            // for some reason, CacheException doesn't call super(msg, cause) but has it's own cause field.
            // Add the cache name too
            // finally, subclass RuntimeException with empty {}
            // to get the more descriptive exception name
            // SelfPopulatingAgedCache$RuntimeException.
            RuntimeException e2 = new RuntimeException(
                    e.getMessage()+ " for cache: "+cache.getName(), e.getInitialCause()){};
            //e2.setStackTrace(e.getStackTrace());   // as if they had done it right
            throw e2;
        }
    }

    // TODO: Fix the real root cause, but meanwhile, this might buy us some time QC 44371
    protected static final class ExceptionEatingCacheEntryFactoryWrapper implements CacheEventListener, CacheEntryFactory {
        private CacheEntryFactory factory;
        private String contains;
        protected ExceptionEatingCacheEntryFactoryWrapper(CacheEntryFactory factory, String contains) {
            this.factory = factory;
            this.contains = contains;
        }

        private Element lastExpiredElement;
        public Object createEntry(Object key) throws Exception {
            try {
                Object ret = factory.createEntry(key);
                lastExpiredElement = null;  // don't leak memory if there's no exception
                return ret;
            } catch (Exception e) {
                if (contains == null || ExceptionUtils.getStackTrace(e).contains(contains)) {
                    if (lastExpiredElement != null && lastExpiredElement.getKey().equals(key)) {
                        Object ret = lastExpiredElement.getObjectValue();   // keep re-using it's data
                        logger.warn(factory.getClass().getName()+
                                " Ignoring exception and using old cache value: ",e);
                        return ret;
                    }
                    logger.warn(factory.getClass().getName()+
                            " Unable to ignore first exception since cache has no old value: "+e);
                }
                throw e;
            }
        }

        public void dispose() {}
        public void notifyElementEvicted(Ehcache ehcache, Element element) {}
        public void notifyElementExpired(Ehcache ehcache, Element element)
        {
            lastExpiredElement = element;  // save it before it goes away
        }
        public void notifyElementPut(Ehcache ehcache, Element element) {}
        public void notifyElementRemoved(Ehcache ehcache, Element element) {}
        public void notifyElementUpdated(Ehcache ehcache, Element element) {}
        public void notifyRemoveAll(Ehcache ehcache) {}
        public Object clone() throws CloneNotSupportedException { return super.clone(); }
    }
}