/*
    ~ Copyright 2006-2007 Nicolas De Loof.
    ~
    ~ 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.jmonit.web;
  
  import java.io.IOException;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.StringTokenizer;
  
  import javax.servlet.Filter;
  import javax.servlet.FilterChain;
  import javax.servlet.FilterConfig;
  import javax.servlet.ServletException;
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.jmonit.Monitor;
  import org.jmonit.Monitoring;
  import org.jmonit.Repository;
  import org.jmonit.Stopwatch;
  import org.jmonit.events.HttpRequestServed;
  
  /**
   * A servlet Filter to be configured in your WEB-INF/web.xml to intercept all
   * incoming request.
   * 
   * <pre>
   *         &lt;filter&gt;
   *         &lt;filter-name&gt;jMonit&lt;/filter-name&gt;
   *         &lt;filter-class&gt;org.jmonit.web.JMonitFilter&lt;/filter-class&gt;
   *         &lt;/filter&gt;
   *         &lt;filter-mapping&gt;
   *         &lt;filter-name&gt;jMonit&lt;/filter-name&gt;
   *         &lt;url-pattern&gt;/*&lt;/url-pattern&gt;
   *         &lt;/filter-mapping&gt;
   * </pre>
   * 
   * <p>
   * A monitor will be created for each application URI. By default, the requested
   * resource extension is used to group monitors in sub-categories.
   * 
   * @author <a href="mailto:nicolas.deloof@gmail.com">Nicolas De Loof</a>
   */
  public class JMonitFilter
      implements Filter
  {
      /**
       *
       */
      private static final String MONITOR_HTTP = "monitor-HTTP";
  
      /** Configuration param for domain mappings */
      private static final String MAPPINGS = "mappings";
  
      /** Configuration param default tag (when no mapping matches) */
      private static final String DEFAULT_TAG = "default-tag";
  
      /** Configuration param tag for web resources */
      private static final String WEB_RESOURCES_TAG = "web-ressources-tag";
  
      /** tag mappings for web resources */
      private Map<String, String> tags = new HashMap<String, String>();
  
      /** Repository of monitors */
      private Repository repository;
  
      /** Default cqtegory for request without matching mapping */
      private String defaultTag = "other";
  
      /** Tag for web resources */
      private String tag = "web";
  
      /** enable HTTP monitoring */
      private boolean monitorHttp;
  
      /**
       * {@inheritDoc}
       * 
       * @see javax.servlet.Filter#destroy()
       */
      public void destroy()
      {
      }
  
     /**
      * Http specific doFilter implementation
      * 
      * @param request Http request
      * @param response Http response
      * @param chain request chain
      * @throws IOException IO exception occurs
      * @throws ServletException servlet Exception occurs
      */
     public void doFilter( HttpServletRequest request, HttpServletResponse response,
                           FilterChain chain )
         throws IOException, ServletException
     {
         String uri = getRequestedUri( request );
 
         String name = buildMonitorNameFromUri( uri );
         Monitor monitor = repository.getMonitor( name ).tag( tag );
         monitor.tag( getTagForUri( uri ) );
 
         Stopwatch execution = Stopwatch.start( monitor );
         try
         {
             if ( monitorHttp )
             {
                 response = new MonitoredHttpServletResponse( response );
             }
             chain.doFilter( request, response );
         }
         finally
         {
             execution.stop();
             if ( monitorHttp )
             {
                 int sc = ( (MonitoredHttpServletResponse) response ).getStatus();
                 monitor.fireMonitoringEvent( new HttpRequestServed( request, execution
                     .getElapsedTime(), sc, monitor ) );
             }
         }
     }
 
     protected String getRequestedUri( HttpServletRequest request )
     {
         String uri = request.getRequestURI();
         String context = request.getContextPath();
         uri = uri.substring( context.length() );
         return uri;
     }
 
     /**
      * Delegates to Http based doFilter. {@inheritDoc}
      * 
      * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest,
      * javax.servlet.ServletResponse, javax.servlet.FilterChain)
      */
     public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain )
         throws IOException, ServletException
     {
         if ( request instanceof HttpServletRequest )
         {
             HttpServletRequest httpRequest = (HttpServletRequest) request;
             HttpServletResponse httpResponse = (HttpServletResponse) response;
             doFilter( httpRequest, httpResponse, chain );
         }
         else
         {
             // Not an HTTP request...
             chain.doFilter( request, response );
         }
 
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
      */
     public void init( FilterConfig filterConfig )
         throws ServletException
     {
         this.monitorHttp = "true".equals( filterConfig.getInitParameter( MONITOR_HTTP ) );
         initRepository( filterConfig );
         initDefaultTags( filterConfig );
         initMapping( filterConfig );
     }
 
     /**
      * @param tags The tags to set
      */
     public void setTags( Map<String, String> tags )
     {
         this.tags = tags;
     }
 
     /**
      * @param repository the repository to set
      */
     public void setRepository( Repository repository )
     {
         this.repository = repository;
     }
 
     /**
      * Build the monitor name from request URI.
      * <p>
      * Override this method in a custom filter to define application specific
      * monitors based on URIs.
      * 
      * @param uri requested URI
      * @return monitor name
      */
     protected String buildMonitorNameFromUri( String uri )
     {
         return uri;
     }
 
     /**
      * Build the monitor name from request URI.
      * <p>
      * Override this method in a custom filter to define application specific
      * monitors based on URIs.
      * 
      * @param uri requested URI
      * @return domain Domain for requested URI
      */
     protected String getTagForUri( String uri )
     {
         String uriTags = defaultTag;
         int i = uri.lastIndexOf( "." );
         if ( i > 0 )
         {
             String extension = uri.substring( i );
             if ( tags.containsKey( extension ) )
             {
                 uriTags = tags.get( extension );
             }
         }
         return uriTags;
     }
 
     /**
      * @param filterConfig configuration
      */
     protected void initDefaultTags( FilterConfig filterConfig )
     {
         String tag = filterConfig.getInitParameter( DEFAULT_TAG );
         if ( tag != null )
         {
             this.defaultTag = tag;
         }
 
         tag = filterConfig.getInitParameter( WEB_RESOURCES_TAG );
         if ( tag != null )
         {
             this.tag = tag;
         }
     }
 
     /**
      * @param filterConfig configuration
      */
     protected void initMapping( FilterConfig filterConfig )
     {
         String maps = filterConfig.getInitParameter( MAPPINGS );
         if ( maps == null )
         {
             // Default mappings
             tags.put( ".do", "struts" );
             tags.put( ".action", "struts2" );
             tags.put( ".jsf", "jsf" );
             tags.put( ".js", "static" );
             tags.put( ".html", "static" );
             tags.put( ".css", "static" );
             tags.put( ".gif", "static" );
             tags.put( ".png", "static" );
             tags.put( ".jpg", "static" );
         }
         else
         {
             StringTokenizer tokenizer = new StringTokenizer( maps );
             while ( tokenizer.hasMoreTokens() )
             {
                 String token = tokenizer.nextToken();
                 int i = token.indexOf( '=' );
                 if ( i < 0 )
                 {
                     continue;
                 }
                 String category = token.substring( 0, i ).trim();
                 tags.put( token.substring( i + 1 ).trim(), category );
             }
         }
     }
 
     /**
      * @param filterConfig configuration
      */
     protected void initRepository( FilterConfig filterConfig )
     {
         if ( repository == null )
         {
             repository = Monitoring.getRepository();
         }
     }
 
 }