/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.jetspeed.cache.impl;
  
  import java.io.Serializable;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import net.sf.ehcache.Cache;
  import net.sf.ehcache.CacheException;
  import net.sf.ehcache.Ehcache;
  import net.sf.ehcache.Element;
  import net.sf.ehcache.event.CacheEventListener;
  import net.sf.ehcache.event.RegisteredEventListeners;
  
  import org.apache.jetspeed.cache.CacheElement;
  import org.apache.jetspeed.cache.DistributedCacheObject;
  import org.apache.jetspeed.cache.JetspeedCache;
  import org.apache.jetspeed.request.RequestContext;
  
  public class EhCacheDistributedImpl extends EhCacheImpl implements JetspeedCache, CacheEventListener
  {
  
  
  	private Map refList = Collections.synchronizedMap(new HashMap());
  
  
  	public EhCacheDistributedImpl(Ehcache ehcache)
  	{
  		super(ehcache);
  		RegisteredEventListeners listeners = ehcache
  				.getCacheEventNotificationService();
  		listeners.registerListener(this);
  
  	}
  
  	public CacheElement get(Object key)
  	{
  		return get((Serializable)key);
  	}
  
  
  	public CacheElement get(Serializable key)
  	{
  		Element element = ehcache.get(key);
  		if (element == null)
  			return null;
  		return new EhCacheDistributedElementImpl(element);
  	}
  
  
  	public boolean isKeyInCache(Object key)
  	{
  		if ((key == null) || (!(key instanceof Serializable)))
  			return false;
  		return ehcache.isKeyInCache(key);
  	}
  
  	public boolean isKeyInCache(Serializable key)
  	{
  		return ehcache.isKeyInCache(key);
  	}
  
  	public void put(CacheElement element)
  	{
  		EhCacheDistributedElementImpl impl = (EhCacheDistributedElementImpl) element;
  		ehcache.put(impl.getImplElement());
  		refList.put(impl.getKey(), impl);
  		notifyListeners(true, CacheElement.ActionAdded,impl.getKey(),impl.getContent());
  	}
  
  	public CacheElement createElement(Object key, Object content)
  	{
  		return new EhCacheDistributedElementImpl((Serializable)key, (DistributedCacheObject)content);
  	}
  
  	public CacheElement createElement(Serializable key, DistributedCacheObject content)
  	{
  		return new EhCacheDistributedElementImpl(key, content);
  	}
  
  
  	public boolean remove(Object key)
 	{
 		return remove ((Serializable) key);
 	}
 
 	public boolean remove(Serializable key)
 	{
 		Element element = ehcache.get(key);
 		refList.remove(key);
 		if (element == null)
 			return false;
         boolean isRemoved = ehcache.remove(key);
         if (isRemoved)
     		notifyListeners(true, CacheElement.ActionRemoved,key,null);
         return isRemoved;
 	}
 
 	public boolean removeQuiet(Object key)
 	{
 		Element element = ehcache.get(key);
 		refList.remove(key);
 		if (element == null)
 			return false;
 		return ehcache.removeQuiet(key);
 
 	}
 
 	public void evictContentForUser(RequestContext context)
 	{
 		return;
 	}
 
 	public String createCacheKey(String primary, String secondary)
 	{
 		return primary;
 	}
 
 	public Object clone() throws CloneNotSupportedException
 	{
 		return null;
 	}
 	
    public void dispose()
     {
 		if (refList != null)
 		{
 			Map temp = refList;
 			refList = null;
 			temp.clear();
 		}
 		else 
 			return;
 		if (this.ehcache != null)
 		{
 			ehcache = null;
 		}
     }
 	
 	public void notifyElement( Ehcache cache, boolean local,Element arg1, int action)
 	{
 		if (cache != this.ehcache)
 		{
 			System.out.println ("Cache=" + cache.getName() + " is not my cache=" + this.ehcache.getName());
 			return;
 		}
 		try
 		{
 			EhCacheDistributedElementImpl e = (EhCacheDistributedElementImpl) refList
 					.get(arg1.getKey());
 			if (e != null)
 			{
 				if (action < 0)
 					refList.remove(arg1.getKey());
 				else if (action == CacheElement.ActionAdded)
 					refList.put(arg1.getKey(), arg1);
 				e.notifyChange(action);
 				notifyListeners(local, action,arg1.getKey(),arg1.getObjectValue());
 			}
 		} catch (Exception e)
 		{
 			e.printStackTrace();
 		}
 	}
 
 	public void notifyElementEvicted(Ehcache cache, Element arg1)
 	{
 			notifyElement(cache, false, arg1,CacheElement.ActionEvicted);
 	}
 
 	public void notifyElementExpired(Ehcache cache, Element arg1)
 	{
 		notifyElement(cache, false, arg1,CacheElement.ActionExpired);
 	}
 
 	public void notifyElementPut(Ehcache cache, Element arg1)
 			throws CacheException
 	{
 		
 			notifyElement(cache, false, arg1, CacheElement.ActionAdded);
 	}
 
 	public void notifyElementRemoved(Ehcache cache, Element arg1)
 			throws CacheException
 	{
 		notifyElement(cache, false, arg1,CacheElement.ActionRemoved);
 	}
 
 	public void notifyElementUpdated(Ehcache cache, Element arg1)
 			throws CacheException
 	{
 		notifyElement(cache, false,arg1,CacheElement.ActionChanged);
 	}
 	public void notifyRemoveAll(Ehcache cache)
 	{
 		if (cache != this.ehcache)
 		{
 			System.out.println ("Cache=" + cache.getName() + " is not my cache=" + this.ehcache.getName());
 			return;
 		}
 		try
 		{
 			Iterator it = refList.entrySet().iterator();
 			while (it.hasNext())
 			{
 				EhCacheDistributedElementImpl e = (EhCacheDistributedElementImpl)it.next();
 				notifyListeners(false, CacheElement.ActionRemoved,e.getKey(),e);
 				e.notifyChange(CacheElement.ActionRemoved);
 			}
 			refList.clear();
 		} catch (Exception e)
 		{
 			e.printStackTrace();
 		}
 
 	
 	}
 
 }