/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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.opensource.org/licenses/gpl-license.php
    *
   * 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.
   */
  package org.figure8.join.services.cache;
  
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  
  import java.util.List;
  import java.util.Collections;
  /**
   * The goal of cache accessor is to provide an easy access to cached data
   * from web-tier layers. As a convenience, it provides a static key for being
   * registered within a ServletContext or some other application context.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class EternalCacheAccessor{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger ... */
     private static Log log = LogUtil.getLog(EternalCacheAccessor.class);
  
     /** An EternalCacheAccessor instance is registered within the web-tier context using this CONTEXT_KEY */
     public static final String CONTEXT_KEY = "cacheAccessor";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The CacheLoader instance for loading eternal data */
     private CacheLoader cacheLoader = null;
     /** The CacheManager instance for retrieving cached data */
     private CacheManager cacheManager = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /**
      * Creates a new instance of EternaleCacheAccessor with initiliazed {@link CacheManager}
      * and loaded eternal caches. The instance of {@link CacheLoader} is also passed as a
      * parameter because cache may have a lazy loading policy. Thus, this accessor will
      * check for loading to occur.
      * @param cacheManager The initiliazed manager to access caches from
      * @param cacheLoader The loader that should have loaded eternal caches.
      */
     public EternalCacheAccessor(CacheManager cacheManager, CacheLoader cacheLoader){
        this.cacheManager = cacheManager;
        this.cacheLoader = cacheLoader;
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @return The CacheManager instance used by this accessor */
     public CacheManager getCacheManager(){
        return cacheManager;
     }
  
     /**
      * Retrieve an arbitrary {@link Cache} using its key identifier
      * @param cacheKey The key of the cache to retrieve
      * @return The Cache object corresponding or null if not found
      */
     public Cache getCache(String cacheKey){
        Cache cache = cacheManager.getCache(cacheKey);
        return cache;
     }
  
     /**
      * Retrieve all the Step domain objects present in cache
      * @return The list of cached {@link org.figure8.join.businessobjects.commons.Step}
      */
     public List getCachedSteps(){
        // Check for lazy loading policy of loader.
        if (!cacheLoader.hasLoadedCaches()){
           try {cacheLoader.loadCaches();}
           catch (Exception e){
              // Log and return empty collection.
              log.error("CacheLoader throws an exception while lazy-loading caches: " + e.getMessage());
              return Collections.EMPTY_LIST;
           }
        }
        // Retrieve steps from corresponding eternal cache.
        Cache cache = cacheManager.getCache(EternalCacheKeys.STEP_ID_TO_STEP_KEY);
        if (cache != null){
           // Get and sort steps (cache may not guarantee order).
          List steps = cache.getElements();
          Collections.sort(steps);
          if (log.isTraceEnabled())
             log.trace("Found " + steps.size() + " cached Steps");
          return steps;
       }
       else{
          log.trace("The cached Step list is empty");
          return Collections.EMPTY_LIST;
       }
    }
 
    /**
     * Retrieve all the Role domain objects present in cache
     * @return The list of cached {@link org.figure8.join.businessobjects.security.Role}
     */
    public List getCachedRoles(){
       // Check for lazy loading policy of loader.
       if (!cacheLoader.hasLoadedCaches()){
          try {cacheLoader.loadCaches();}
          catch (Exception e){
             // Log and return empty collection.
             log.error("CacheLoader throws an exception while lazy-loading caches: " + e.getMessage());
             return Collections.EMPTY_LIST;
          }
       }
       // Retrieve roles from corresponding eternal cache.
       Cache cache = cacheManager.getCache(EternalCacheKeys.ROLE_NAME_TO_ROLE_KEY);
       if (cache != null){
          // Get and sort roles (cache may not guarantee order).
          List roles = cache.getElements();
          Collections.sort(roles);
          if (log.isTraceEnabled())
             log.trace("Found " + roles.size() + " cached Roles");
          return roles;
       }
       else{
          log.trace("The cached Role list is empty");
          return Collections.EMPTY_LIST;
       }
    }
 
    /**
     * Retrieve all the Release domain objects present in cache
     * @return The list of cached {@link org.figure8.join.businessobjects.commons.Release}
     */
    public List getCachedReleases(){
       // Check for lazy loading policy of loader.
       if (!cacheLoader.hasLoadedCaches()){
          try {cacheLoader.loadCaches();}
          catch (Exception e){
             // Log and return empty collection.
             log.error("CacheLoader throws an exception while lazy-loading caches: " + e.getMessage());
             return Collections.EMPTY_LIST;
          }
       }
       // Retrieve releases from corresponding eternal cache.
       Cache cache = cacheManager.getCache(EternalCacheKeys.RELEASE_NAME_TO_RELEASE_KEY);
       if (cache != null){
          // Get and sort releases (cache may not guarantee order).
          List releases = cache.getElements();
          Collections.sort(releases, Collections.reverseOrder());
          if (log.isTraceEnabled())
             log.trace("Found " + releases.size() + " cached Releases");
          return releases;
       }
       else{
          log.trace("The cached Release list is empty");
          return Collections.EMPTY_LIST;
       }
    }
 
    /**
     * Retrieve all the DeliverableType domain objects present in cache
     * @return The list of cached {@link org.figure8.join.businessobjects.artifact.DeliverableType}
     */
    public List getCachedDeliverableTypes(){
       // Check for lazy loading policy of loader.
       if (!cacheLoader.hasLoadedCaches()){
          try {cacheLoader.loadCaches();}
          catch (Exception e){
             // Log and return empty collection.
             log.error("CacheLoader throws an exception while lazy-loading caches: " + e.getMessage());
             return Collections.EMPTY_LIST;
          }
       }
       // Retrieve deliverable types from corresponding eternal cache.
       Cache cache = cacheManager.getCache(EternalCacheKeys.DELTYPE_KEY_TO_DELTYPE_KEY);
       if (cache != null){
          // Get and sort types (cache may not guarantee order).
          List types = cache.getElements();
          Collections.sort(types);
          if (log.isTraceEnabled())
             log.trace("Found " + types.size() + " cached DeliverableTypes");
          return types;
       }
       else{
          log.trace("The cached DeliverableType list is empty");
          return Collections.EMPTY_LIST;
       }
    }
 }