/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   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.gridsystems.innergrid.kernel.genericutils;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.atomic.AtomicLong;
  
  import org.apache.commons.lang.NullArgumentException;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.gridsystems.exceptions.PagedRequestException;
  import com.gridsystems.exceptions.PagedRequestNotAllowedException;
  import com.gridsystems.exceptions.PagedRequestNotFoundException;
  import com.gridsystems.innergrid.kernel.server.KernelContext;
  
  /**
   * Centralized management for asynchronous requests being performed.
   *
   * @author lgaspart
   * @author Xmas (generics)
   * @author Rodrigo Ruiz (bug fixes)
   * @version 1.0
   * @param <E> Specific PagedRequest to manage
   */
  public final class PagedRequestManager<E extends PagedRequest<?>> {
    /**
     * Default timeout value in milliseconds.
     */
    private static final long DEFAULT_TIMEOUT = 200000;
  
    /**
     * Default clean sleep time in milliseconds.
     */
    private static final long DEFAULT_SLEEP = 60000;
  
    /**
     * All logs are done through this instance.
     */
    private static final Log LOG = LogFactory.getLog(PagedRequestManager.class);
  
    /**
     * Used to build thread names.
     */
    private static final AtomicLong CLEAN_THREAD_ID = new AtomicLong(0);
  
    /**
     * Reference to the cleaning thread.
     */
    private CleaningThread cleanThread = null;
  
    /**
     * Time interval in milliseconds for a not accessed request to be considered
     * timed out.
     */
    private long timeoutThreshold = DEFAULT_TIMEOUT;
  
    /**
     * Time to sleep (in milliseconds) between successive cleaning thread loops.
     */
    private long cleanSleep = DEFAULT_SLEEP;
  
    /**
     * Collection where all the requests are stored.
     */
    private Map<Long, E> pagedRequests
      = Collections.synchronizedMap(new HashMap<Long, E>());
  
    /**
     * Private constructor.
     */
    public PagedRequestManager() {
    }
  
    /**
     * {@inheritDoc}
     */
    @Override protected void finalize() throws Throwable {
      removeAllPagedRequest();
      super.finalize();
   }
 
   /**
    * Makes sure the cleaner thread is up and running.
    */
   private void initCleaner() {
     if (this.cleanThread == null) {
       this.cleanThread = new CleaningThread(CLEAN_THREAD_ID.addAndGet(1L));
       this.cleanThread.start();
     }
   }
 
   /**
    * Shutdowns the cleaner thread.
    */
   private void disposeCleaner() {
     if (this.cleanThread != null) {
       this.cleanThread.interrupt();
       this.cleanThread = null;
     }
   }
 
   /**
    * Adds a PagedRequest to the collection of the manager.
    *
    * @param req PagedRequest to be added
    * @throws NullArgumentException if req is null
    */
   public void addPagedRequest(E req) throws NullArgumentException {
     if (req == null) {
       throw new NullArgumentException("req");
     }
 
     initCleaner();
     pagedRequests.put(Long.valueOf(req.getId()), req);
   }
 
   /**
    * Obtains a PagedRequest from the managed pool.
    *
    * @param id Identifier of the asked for PagedRequest
    * @return PagedRequest whose identifier matches 'id' parameter
    * @throws PagedRequestNotFoundException if there is no PagedRequest with that id
    * @throws PagedRequestNotAllowedException if the current user did not create the
    *                                         request
    */
   public E getPagedRequest(long id)
     throws PagedRequestNotFoundException, PagedRequestNotAllowedException {
     return getPagedRequest(id, true);
   }
 
   /**
    * Obtains a PagedRequest from the managed pool.
    *
    * @param id identifier of the PagedRequest
    * @param secure true if security checking must be done
    * @return a PagedRequest object identified by the 'id' parameter
    * @throws PagedRequestNotFoundException if there is no PagedRequest with that id
    * @throws PagedRequestNotAllowedException if the current user did not create the
    *                                         request
    */
   private E getPagedRequest(long id, boolean secure)
     throws PagedRequestNotFoundException, PagedRequestNotAllowedException {
     E req = pagedRequests.get(id);
 
     if (req == null) {
       throw new PagedRequestNotFoundException();
     }
 
     String currentUserName = KernelContext.getContext().getUserName();
     if (secure && (currentUserName != null) && !currentUserName.equals(req.getUser())) {
       throw new PagedRequestNotAllowedException();
     }
 
     return req;
   }
   /**
    * Gets all paged requests that are instances of the specified class.
    *
    * @return A collection containing all selected paged requests
    */
   public List<E> getAllPagedRequests() {
     List<E> list = new ArrayList<E>(pagedRequests.values());
     return list;
   }
 
   /**
    * Gets the size of the collection of managed paged requests.
    *
    * @return size of the collection of managed paged requests
    */
   public int getPagedRequestsSize() {
     return pagedRequests.size();
   }
 
   /**
    * Cancels and Removes all paged request from the collection of the manager.
    */
   public void removeAllPagedRequest() {
     final int count = this.pagedRequests.keySet().size();
     Long[] ids = this.pagedRequests.keySet().toArray(new Long[count]);
     for (Long id : ids) {
       try {
         removePagedRequest(id, false);
       } catch (PagedRequestException e) {
         LOG.error("Exception thrown when removing paged request " + id, e);
       }
     }
   }
 
   /**
    * Removes a paged request from the collection of the manager, given its 'id'.
    *
    * @param id identifier of the paged request to be removed
    * @throws PagedRequestNotFoundException if there is no request matching the id
    * @throws PagedRequestNotAllowedException if the current user did not create
    *                                         the request
    */
   public void removePagedRequest(long id)
     throws PagedRequestNotFoundException, PagedRequestNotAllowedException {
     removePagedRequest(id, true);
   }
 
   /**
    * Removes a paged request from the collection of the manager, given its 'id'.
    * Before removing, it calls to the clear method of the PagedRequest
    * @param id identifier of the paged request to be removed
    * @param secure true if security checking must be done
    * @throws PagedRequestNotFoundException if there is no request matching the id
    * @throws PagedRequestNotAllowedException if the current user did not create
    *                                         the request
    */
   private void removePagedRequest(long id, boolean secure)
     throws PagedRequestNotFoundException, PagedRequestNotAllowedException {
 
     E pr = getPagedRequest(id, secure);
 
     try {
       pr.clear();
     } catch (Exception e) {
       LOG.error("Unable to clear Paged Request number " + id);
     }
 
     //Removes request from list
     pagedRequests.remove(id);
 
     if (pagedRequests.isEmpty()) {
       disposeCleaner();
     }
   }
 
 
   /**
    * Gets a String representation of this object.
    *
    * @return a string representation of this object
    */
   @Override public String toString() {
     return "PagedRequestManager { requests number = " + pagedRequests.size()
       + ", timeout limit = " + timeoutThreshold + " }";
   }
 
   /**
    * Thread in charge to clean obsolete requests.
    */
   class CleaningThread extends Thread {
 
     /**
      * Creates a new instance.
      */
     public CleaningThread(long id) {
       setName("CleaningThread-" + id);
       setDaemon(true);
     }
 
     /**
      * Removes from the collection of requests those not accessed during
      * timeoutThreshold milliseconds.
      */
     @Override public void run() {
       while (!isInterrupted()) {
         // Builds a list with the requests to remove
         long now = System.currentTimeMillis();
         ArrayList<E> toRemove = new ArrayList<E>();
         synchronized (pagedRequests) {
           Iterator<E> it = pagedRequests.values().iterator();
           while (it.hasNext()) {
             E pr =  it.next();
             if (now - pr.getLastAccessTime() > timeoutThreshold) {
               toRemove.add(pr);
             }
           }
         }
 
         // Removes all requests in the list
         Iterator<E> it = toRemove.iterator();
         while (it.hasNext()) {
           E req = it.next();
           long id = req.getId();
           try {
             removePagedRequest(id, false);
           } catch (PagedRequestNotFoundException e) {
             LOG.warn("Paged Request " + id + " could not be removed: not found");
           } catch (PagedRequestNotAllowedException e) {
             LOG.warn("Paged Request " + id + " could not be removed: not allowed");
           }
         }
 
         // Hibernates until the next loop
         try {
           Thread.sleep(cleanSleep);
         } catch (InterruptedException e) { }
       }
     }
   }
 }