/*
   MadCaching is a Tile Caching solution
   Copyright (C) 2005  Mac Vu
   
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.
   
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   */
  package com.macvu.tiles.capture;
  
  import com.macvu.tiles.CacheComponentDefinition;
  import com.macvu.tiles.CacheAttribute;
  
  import javax.servlet.ServletContext;
  import javax.servlet.jsp.PageContext;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpSession;
  import java.util.Enumeration;
  import java.util.Set;
  
  import org.apache.commons.logging.LogFactory;
  import org.apache.commons.logging.Log;
  
  public class CacheablesCaptureWrapper {
      protected static Log log = LogFactory.getLog(CacheablesCaptureWrapper.class);
      public static final String TILES_CACHEABLE_CAPTURE = "TILES_CACHEABLE_CAPTURE";
      TilesCacheableCapture tilesCacheableCapture;
      public CacheablesCaptureWrapper(ServletContext servletContext) {
          init(servletContext);
      }
  
      synchronized protected void init(ServletContext servletContext) {
          tilesCacheableCapture = (TilesCacheableCapture) servletContext.getAttribute(TILES_CACHEABLE_CAPTURE);
  
          if (tilesCacheableCapture == null) {
              tilesCacheableCapture = new TilesCacheableCapture();
  
              servletContext.setAttribute(TILES_CACHEABLE_CAPTURE, tilesCacheableCapture);
          }
      }
  
      public boolean isEnableCapture() {
          return tilesCacheableCapture.isEnableCapture();
      }
  
      public void enableCapture() {
          tilesCacheableCapture.setEnableCapture(true);
      }
  
      public void disableCapture() {
          tilesCacheableCapture.setEnableCapture(false);
      }
  
      public void clearCapturedTilesSet() {
          tilesCacheableCapture.clearCapturedTilesSet();
      }
  
      public void captureCacheablesForTile(CacheComponentDefinition definition, HttpServletRequest request) {
          addCacheablesForTile(definition, request);
  
          HttpSession session = request.getSession();
          if (session != null) {
              addCacheablesForTile(definition, session);
          }
  
          // Let's not do the Application Scope for now until we find a reason to do it.
  
          if (log.isDebugEnabled()) {
              log.debug("Captured Tile: " + definition.getName());
          }
          tilesCacheableCapture.putCapturedTile(definition.getName());
      }
  
      public void captureCacheablesForTile(CacheComponentDefinition definition, PageContext pageContext) {
          addCacheablesForTile(definition, pageContext);
  
  
          HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
  
          captureCacheablesForTile(definition, request);
      }
  
  
      public Set getCapturedTiles() {
          return tilesCacheableCapture.getCapturedTiles();
      }
  
      protected void addCacheablesForTile(CacheComponentDefinition definition, PageContext pageContext) {
          Enumeration pageEnum = pageContext.getAttributeNamesInScope(PageContext.PAGE_SCOPE);
         while (pageEnum.hasMoreElements()) {
             String pageName = (String) pageEnum.nextElement();
             CacheAttribute newAttribute = new CacheAttribute(pageName, CacheAttribute.PAGE_SCOPE);
             if (log.isDebugEnabled()) {
                 log.debug("Add to tile: " + definition.getName() + " cacheable attribute: " + newAttribute.toString());
             }
             definition.getCacheInformation().addPossibleCacheAttribute(newAttribute);
         }
     }
 
     protected void addCacheablesForTile(CacheComponentDefinition definition, HttpServletRequest request) {
         Enumeration paramEnum = request.getParameterNames();
         while (paramEnum.hasMoreElements()) {
             String paramName = (String) paramEnum.nextElement();
             CacheAttribute newAttribute = new CacheAttribute(paramName, CacheAttribute.PARAM_SCOPE);
 
             if (log.isDebugEnabled()) {
                 log.debug("Add to tile: " + definition.getName() + " cacheable attribute: " + newAttribute.toString());
             }
             definition.getCacheInformation().addPossibleCacheAttribute(newAttribute);
         }
 
         Enumeration requestEnum = request.getAttributeNames();
         while (requestEnum.hasMoreElements()) {
             String requestName = (String) requestEnum.nextElement();
             CacheAttribute newAttribute = new CacheAttribute(requestName, CacheAttribute.REQUEST_SCOPE);
             if (log.isDebugEnabled()) {
                 log.debug("Add to tile: " + definition.getName() + " cacheable attribute: " + newAttribute.toString());
             }
             definition.getCacheInformation().addPossibleCacheAttribute(newAttribute);
         }
     }
 
     protected void addCacheablesForTile(CacheComponentDefinition definition, HttpSession session) {
         Enumeration sessionEnum = session.getAttributeNames();
         while (sessionEnum.hasMoreElements()) {
             String sessionName = (String) sessionEnum.nextElement();
             CacheAttribute newAttribute = new CacheAttribute(sessionName, CacheAttribute.SESSION_SCOPE);
             if (log.isDebugEnabled()) {
                 log.debug("Add to tile: " + definition.getName() + " cacheable attribute: " + newAttribute.toString());
             }
             definition.getCacheInformation().addPossibleCacheAttribute(newAttribute);
         }
     }
 }