/*
    ~ 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.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.StringTokenizer;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  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.log.Log;
  import org.jmonit.reporting.JSonRenderer;
  import org.jmonit.reporting.Renderer;
  import org.jmonit.spi.PluginManager;
  
  /**
   * @author <a href="mailto:nicolas.deloof@gmail.com">Nicolas De Loof</a>
   */
  public class RestServlet
      extends HttpServlet
  {
      /** logger */
      private static Log log = Log.getLog( RestServlet.class );
  
      /**
       *
       */
      private static final long serialVersionUID = 1L;
  
      /**
       *
       */
      private static final String TAG = "/tag/";
  
      /**
       *
       */
      private static final String MONITORS = "/monitors";
  
      private static final String MONITOR = "/monitor/";
  
      private Map<String, Renderer> renderers = new HashMap<String, Renderer>();
  
      private Repository repository = Monitoring.getRepository();
      {
          renderers.put( "application/json", new JSonRenderer( null ) );
          renderers.put( "text/javascript", new JSonRenderer( null ) );
      }
  
      /**
       * {@inheritDoc}
       * 
       * @see javax.servlet.http.HttpServlet#service(javax.servlet.http.HttpServletRequest,
       * javax.servlet.http.HttpServletResponse)
       */
      protected void service( HttpServletRequest request, HttpServletResponse response )
          throws ServletException, IOException
      {
          List<String> mimeTypes = MimeUtils.getMimeTypes( request );
          restService( request.getPathInfo(), mimeTypes, response );
      }
  
      protected void restService( String path, List<String> mimeTypes, HttpServletResponse response )
          throws IOException
      {
          Renderer renderer = getRenderer( mimeTypes, response );
          if ( renderer == null )
          {
              response.sendError( HttpServletResponse.SC_NOT_IMPLEMENTED );
              return;
          }
          StringBuffer location = new StringBuffer( path );
          Object resource = getRestResource( location );
          if ( resource == null )
          {
              // TODO check if this is the REST-way to handle unsupported path
             response.sendError( HttpServletResponse.SC_BAD_REQUEST );
             return;
         }
 
         if ( location.length() > 0 && location.charAt( 0 ) == '/' )
         {
             location.delete( 0, 1 );
         }
         if ( log.isDebugEnabled() )
         {
             log.debug( "request for " + path );
             log.debug( "resource is " + path.substring( 0, path.length() - location.length() ) );
             log.debug( "features are " + location.toString() );
         }
         Collection<Class> features = getFeatures( location.toString() );
 
         response.addHeader( "Cache-Control", "no-cache" );
         if ( resource instanceof Collection )
         {
             Collection<Monitor> collection = (Collection<Monitor>) resource;
             renderer.render( new MonitorsIterator( collection.iterator(), features ) );
         }
         if ( resource instanceof Monitor )
         {
             Collection<Monitor> collection = new ArrayList<Monitor>();
             collection.add( (Monitor) resource );
             renderer.render( new MonitorsIterator( collection.iterator(), features ) );
         }
     }
 
     /**
      * Find the jmonit resource pointed by the request path.
      * 
      * @param request HTTP request
      * @return a resource objet
      */
     protected Object getRestResource( StringBuffer path )
     {
         if ( path.toString().startsWith( MONITOR ) )
         {
             path.delete( 0, MONITOR.length() - 1 );
             String name;
             int i = path.indexOf( "/" );
             if ( i > 0 )
             {
                 name = path.substring( 0, i );
                 path.delete( 0, i + 1 );
             }
             else
             {
                 name = path.toString();
                 path.setLength( 0 );
             }
             Monitor monitor = repository.getMonitor( name );
             return monitor;
         }
 
         if ( path.toString().startsWith( MONITORS ) )
         {
             Collection<Monitor> monitors = null;
             path.delete( 0, MONITORS.length() );
 
             if ( path.toString().startsWith( TAG ) )
             {
                 path.delete( 0, TAG.length() );
                 String tag;
                 int i = path.indexOf( "/" );
                 if ( i > 0 )
                 {
                     tag = path.substring( 0, i );
                     path.delete( 0, i + 1 );
                 }
                 else
                 {
                     tag = path.toString();
                     path.setLength( 0 );
                 }
                 monitors = repository.getMonitorsWithTag( tag );
             }
             else
             {
                 monitors = repository.getMonitors();
             }
             return monitors;
         }
         else
         {
             // Unsupported
             return null;
         }
     }
 
     private Collection<Class> getFeatures( String path )
     {
         if ( path.charAt( 0 ) == '/' )
         {
             path = path.substring( 1 );
         }
 
         PluginManager manager = Monitoring.getRepository().getFeatureManager();
         Collection<Class> features = new ArrayList<Class>();
         StringTokenizer tokenizer = new StringTokenizer( path, "+" );
         while ( tokenizer.hasMoreTokens() )
         {
             Class feature = manager.getFeature( tokenizer.nextToken() );
             if ( feature != null )
             {
                 features.add( feature );
             }
         }
         return features;
     }
 
     /**
      * Find the best renderer according to the accept header (mime-type)
      * 
      * @param request HTTP request
      * @param response HTTP response
      * @return a renderer
      * @throws IOException some error occured
      */
     protected Renderer getRenderer( List<String> mimeTypes, HttpServletResponse response )
         throws IOException
     {
         for ( String mimeType : mimeTypes )
         {
             Renderer clonable = renderers.get( mimeType );
             if ( clonable == null )
             {
                 continue;
             }
             Renderer renderer = clonable.createNew( response.getWriter() );
             response.setContentType( mimeType );
             if ( log.isDebugEnabled() )
             {
                 log.debug( "rendering resource with " + renderer.getClass().getName() );
             }
             return renderer;
         }
         return null;
     }
 }