/**
    * Copyright (C) 2005-2009 Alfresco Software Limited.
    *
    * This file is part of the Spring Surf Extension project.
    *
    * 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 org.springframework.extensions.surf.task;
  
  import java.util.HashMap;
  import java.util.Queue;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Basic implementation of a task manager for use in asynchronous 
   * processing and monitoring of tasks.
   * 
   * Tasks are added to the task manager.  When added, they are 
   * assigned a reference id so that subsequent calls to the task
   * manager can check on the task status.
   * 
   * A task starter thread wakes up occasionally and checks whether 
   * there are any tasks waiting to be processed.
   * 
   * If a task is found, it is attached to a task worker thread and 
   * then executed.  When the task worker thread completes, it is 
   * handed back to the task worker thread pool.
   * 
   * @author muzquiano
   */
  public class TaskManager
  {
      private static Log logger = LogFactory.getLog(TaskManager.class);
  
      // the thread launcher thread
      private TaskStarterThread taskStarterThread = null;
      
      // our collection of worker threads
      private HashMap<String, TaskWorkerThread> threads;
  
      // tasks that are queued up for us to do
      private Queue<AbstractTask> taskQueue = null;
  
      // all tasks that are running
      private HashMap<String, AbstractTask> allTasks = null;
  
      // maximum number of tasks we should run concurrently
      private int threadPoolSize = 5;
      
      // how often the nightcrawler should wake up to check
      // if there are new jobs to process
      private int wakeupPeriod = 1000;
  
      public TaskManager()
      {
      }
      
      public void init()
      {
          // initialize all collections
          taskQueue = new java.util.PriorityQueue<AbstractTask>();
          allTasks = new HashMap<String, AbstractTask>();
          threads = new HashMap<String, TaskWorkerThread>();        
  
          // create the nightkeeper thread that will make sure
          // that tasks are being processed
          taskStarterThread = new TaskStarterThread(this);
          taskStarterThread.start();
  
          // stock our available threads
          for (int i = 0; i < getThreadPoolSize(); i++)
          {
              TaskWorkerThread thread = new TaskWorkerThread(this);
              getThreads().put(thread.getName(), thread);
              thread.start();
  
              if (logger.isDebugEnabled())
                  logger.debug("Added WorkerThread to pool (" + (i + 1) + " of " + getThreadPoolSize() + ")");
          }        
      }
      
      public void setThreadPoolSize(int threadPoolSize)
      {
          this.threadPoolSize = threadPoolSize;
      }
      
     public int getThreadPoolSize()
     {
         return this.threadPoolSize;
     }
     
     public void setWakeupPeriod(int wakeupPeriod)
     {
         this.wakeupPeriod = wakeupPeriod;
     }
     
     public int getWakeupPeriod()
     {
         return this.wakeupPeriod;
     }
 
     public int getThreadCount()
     {
         return threads.size();
     }
 
     public int getTaskQueueCount()
     {
         return taskQueue.size();
     }
 
     public synchronized String addTask(AbstractTask task)
     {
         taskQueue.add(task);
         allTasks.put(task.getId(), task);
 
         // return the task id
         return task.getId();
     }
 
     /**
      * Returns a task that is running or has finished running
      */
     public AbstractTask getTask(String taskId)
     {
         return (AbstractTask) allTasks.get(taskId);
     }
 
     /**
      * Returns all of the tasks
      */
     public HashMap<String, AbstractTask> getAllTasks()
     {
         return allTasks;
     }
 
     public void remove(String taskId)
     {
         AbstractTask task = getTask(taskId);
         if (task != null)
         {
             remove(task);
         }
     }
 
     public void remove(AbstractTask task)
     {
         if (task != null && task.isFinished())
         {
             allTasks.remove(task.getId());
         }
     }
 
     public Queue<AbstractTask> getTaskQueue()
     {
         return taskQueue;
     }
 
     public HashMap<String, TaskWorkerThread> getThreads()
     {
         return threads;
     }
 
     public void cancel(String taskId)
     {
         AbstractTask task = getTask(taskId);
         if (task != null)
         {
             task.setStatus("Cancel called for the task");
             task.cancel();
             task.setStatus("Cancellation completed");
             task.isCancelled = true;
         }
     }
 }