/**
    * 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.site;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.ServletRequest;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.extensions.surf.FrameworkUtil;
  import org.springframework.extensions.surf.RequestContext;
  import org.springframework.extensions.surf.render.RenderContext;
  
  /**
   * A class that provides facilities for keeping track of the
   * rendering times of components, regions, templates and pages.
   * 
   * The framework will call into this class when execution of said
   * pieces.  If it is not enabled, then these calls will just NOP.
   * Otherwise, they will log using the Framework logger.
   * 
   * @author muzquiano
   */
  public class Timer
  {
      protected static String TIMER_KEY = "timer";
      protected static Log logger = LogFactory.getLog(Timer.class);
      
      /**
       * Either print out to the configured Timer logger
       * Or if they haven't set that up, just dump out to console
       */
      protected static void print(String value)
      {
          if (logger.isDebugEnabled())
          {
              logger.debug(value);
          }
      }
      
      /**
       * Determines whether the timer is enabled.
       * This is controlled via the configuration file and is false by default.
       * 
       * @return Whether the timer functionality is enabled or not
       */
      public static boolean isTimerEnabled()
      {
          return FrameworkUtil.getWebFrameworkConfiguration().isTimerEnabled();
      }
      
      /**
       * @return Whether to report in milliseconds (rather than nanoseconds)
       */
      protected static boolean showMilliseconds()
      {
          return true;
      }
      
      /**
       * Binds a timer container to the current context
       * This must be called at the top of the request execution chain
       * 
       * @param context The current request context
       */
      public static void bindTimer(ServletRequest request)
      {
          bindTimer(request, false);
      }
      
      public static void bindTimer(ServletRequest request, boolean forceNew)
      {
          Timer t = (Timer) request.getAttribute(TIMER_KEY);
          if (t == null || forceNew)
          {
              t = new Timer();
              request.setAttribute(TIMER_KEY, t);
          }
     }
     
     /**
      * Releases the timer.  This should be called at the end of the
      * request processing chain
      * 
      * @param context The current request context
      */
     public static void unbindTimer(ServletRequest request)
     {
         request.removeAttribute(TIMER_KEY);
     }
     
     public static void start(RenderContext context, String blockId)
     {
         start(context.getRequest(), blockId);
     }
     
     /**
      * Begins timing for a specific block.  If timing has been captured
      * previously for this block id, it will be added upon
      * 
      * @param context The current request context
      * @param blockId The unique id of the block
      */
     public static void start(ServletRequest request, String blockId)
     {
         if (blockId == null)
         {
             return;
         }
         
         Timer t = (Timer) request.getAttribute(TIMER_KEY);
         if (t != null)
         {
             // check if this timer has not already been started
             if (t.startTimes.get(blockId) == null)
             {
                 t.keys.add(blockId);
             }
             
             Long l = new Long(System.nanoTime());
             t.startTimes.put(blockId, l);
         }
     }
     
     public static void stop(RenderContext context, String blockId)
     {
         stop(context.getRequest(), blockId);
     }
     
     public static void stop(ServletRequest request, String blockId)
     {
         long endTime = System.nanoTime();
 
         Timer t = (Timer) request.getAttribute(TIMER_KEY);
         if (t != null)
         {
             // start time
             Long startTime = (Long) t.startTimes.get(blockId);
             if (startTime != null)
             {
                 // execution time
                 long executionTime = endTime - startTime.longValue();
                 
                 // add to total time
                 Long totalTime = (Long) t.totalTimes.get(blockId);
                 if (totalTime == null)
                 {
                     totalTime = new Long(executionTime);
                 }
                 else
                 {
                     totalTime = new Long(totalTime.longValue() + executionTime);
                 }
                 
                 // store back
                 t.totalTimes.put(blockId, totalTime);
             }
         }
     }
     
     /**
      * Writes to debug out the report for a single block id
      * 
      * @param context The current request context
      * @param blockId The block id to report on
      */
     public static void report(ServletRequest request, String blockId)
     {
         Timer t = (Timer) request.getAttribute(TIMER_KEY);
         if (t != null)
         {
             Long l = (Long) t.totalTimes.get(blockId);
             if (l != null)
             {
                 long value = (long) l.longValue();
                 String label = "ns";
                 
                 if (Timer.showMilliseconds())
                 {
                     value = (long)(value / 1000000);
                     label = "ms";
                 }
 
                 RequestContext context = FrameworkUtil.getCurrentRequestContext();
                 if (context == null)
                 {
                     print("[" + blockId + "] took " + value + " " + label);
                 }
                 else
                 {
                     print("[" + context.getId() + ":" + blockId + "] took " + value + " " + label);
                 }
             }
         }
     }
     
     public static void reportAll(ServletRequest request)
     {
         Timer t = (Timer) request.getAttribute(TIMER_KEY);
         if (t != null)
         {
             // report timing blocks in order they were received
             Iterator it = t.keys.iterator();
             while (it.hasNext())
             {
                 String blockId = (String) it.next();
                 report(request, blockId);
             }
         }
     }
     
     public Timer()
     {
         this.totalTimes = new HashMap<String, Long>();
         this.startTimes = new HashMap<String, Long>();
         this.keys = new ArrayList<String>();
     }
     
     protected Map<String, Long> totalTimes;
     protected Map<String, Long> startTimes;
     protected List<String> keys;
 }