/*
    * Copyright 2004-2005 Andreas Andreou
    *
    * Licensed 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 net.sf.tapfx.components.cache;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.Serializable;
  import java.io.UnsupportedEncodingException;
  
  import net.sf.ehcache.CacheException;
  import net.sf.ehcache.CacheManager;
  import net.sf.ehcache.Element;
  
  import org.apache.tapestry.AbstractComponent;
  import org.apache.tapestry.IMarkupWriter;
  import org.apache.tapestry.IRequestCycle;
  
  /***
   * A Tapestry component that caches web content.<BR>
   * Surround the html content that should be cached with this component,
   * and specify the cache name and (an optional) cache key.
   * Ehcache is used to implement the caching, and so
   * eache cache's properties are configured in the ehcache.xml file.
   * This class also contains static utility methods for interacting
   * with a cache from code, such as: get, put, remove, clear.
   * @author andyhot
   */
  public abstract class Cache extends AbstractComponent
  {
      private static final Log log = LogFactory.getLog(Cache.class);
  
      public abstract String getName();
      public abstract Object getKey();
  
      protected void renderComponent(IMarkupWriter writer, IRequestCycle cycle)
      {
          if (cycle.isRewinding())
          {
              return;
          }
          net.sf.ehcache.Cache cache = getCache(getName());
          if (cache == null)
          {
              log.info("Cache not found: " + getName());
          }
          else
          {
              log.debug("HitCount: " + cache.getHitCount()
                      + " Size: " + cache.getMemoryStoreSize());
  
              String cachedHtml = (String) Cache.get( cache, getKey());
              if (cachedHtml != null)
              {
                  writer.printRaw(cachedHtml);
                  writer.comment("Cache hit");
                  return;
              }
  
          }
          if (log.isDebugEnabled())
          {
              log.debug("Generating cache content for cache: " + getName() + " and key: " + getKey());
          }
          // first, render the body in a byte array
          // in 4.0 we can use the nested writer, because it publishes
          // a getBuffer() method to get its contents. In 3.0 this does not exit!
          ByteArrayOutputStream stream = new ByteArrayOutputStream();
          IMarkupWriter nested = getPage().getResponseWriter(stream);
          renderBody(nested, cycle);
          nested.close();
          // now, we have to use the char encoding to turn the byte array into string
          String bodyHtml = "";
          try
          {
              String ct = nested.getContentType();
              if (ct != null)
              {
  	            int pos = ct.lastIndexOf("=");
  	            if (pos >= 0)
  	            {
  	                ct = ct.substring(pos+1);
  	            }
  	            bodyHtml = stream.toString(ct);
             }
         }
         catch (UnsupportedEncodingException e)
         {
             e.printStackTrace();
             bodyHtml = stream.toString();
         }
         writer.printRaw(bodyHtml);
         put(cache, getKey(), bodyHtml);
     }
 
     private static net.sf.ehcache.Cache getCache(String name)
     {
         net.sf.ehcache.Cache cache = null;
         try
         {
             CacheManager manager = CacheManager.getInstance();
             cache = manager.getCache(name);
             if (cache == null)
             {
                 log.warn("Could not find configuration for " + name
                         + ". Configuring using the defaultCache settings.");
                 manager.addCache(name);
                 cache = manager.getCache(name);
             }
         }
         catch (net.sf.ehcache.CacheException e)
         {
         }
         return cache;
     }
 
     public static Object get(String cacheName, Object key)
     {
         net.sf.ehcache.Cache cache = getCache(cacheName);
         return get(cache, key);
     }
 
     public static void put(String cacheName, Object key, Object value)
     {
         net.sf.ehcache.Cache cache = getCache(cacheName);
         put(cache, key, value);
     }
 
     public static void remove(String cacheName, Object key)
     {
         net.sf.ehcache.Cache cache = getCache(cacheName);
         if (cache != null)
         {
             cache.remove((Serializable) key);
         }
     }
 
     public static void clear(String cacheName)
     {
         net.sf.ehcache.Cache cache = getCache(cacheName);
         if (cache != null)
         {
             try
             {
                 cache.removeAll();
             }
             catch (IOException ignore)
             {
             }
         }
     }
 
     private static void put(net.sf.ehcache.Cache cache, Object key, Object value)
     {
         if (cache != null)
         {
             Element element = new Element((Serializable) key, (Serializable) value);
             cache.put(element);
         }
     }
 
     private static Object get(net.sf.ehcache.Cache cache, Object key)
     {
         Object obj = null;
         if (cache != null)
         {
             try
             {
                 Element element = cache.get((Serializable) key);
                 if (element !=null)
                 {
                     obj = element.getValue();
                 }
             }
             catch (CacheException ignore)
             {
             }
         }
         return obj;
     }
 }