/*
    ~ 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.lang.reflect.Array;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  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.Monitoring;
  import org.jmonit.reporting.JSonRenderer;
  import org.jmonit.reporting.Renderer;
  import org.jmonit.spi.PluginManager;
  
  /**
   * Access to the repository datas using REST URLs. Inspired by stapler to
   * convert a REST path to navigation in Java object graph, but dedicated to
   * monitors and features handling.
   * 
   * @see https://stapler.dev.java.net/what-is.html
   * @author <a href="mailto:nicolas.deloof@gmail.com">Nicolas De Loof</a>
   */
  public class RestServlet2
      extends HttpServlet
  {
      /**
       * {@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
      {
          Object resource = Monitoring.getRepository();
          try
          {
              resource = findResource( split( request.getPathInfo() ), resource );
          }
          catch ( Exception e )
          {
              response.sendError( HttpServletResponse.SC_NOT_FOUND );
          }
          if ( resource == null )
          {
              response.setStatus( HttpServletResponse.SC_NO_CONTENT );
              return;
          }
  
          Renderer renderer = getRenderer( MimeUtils.getMimeTypes( request ), response );
  
          // renderer.render( resource );
  
      }
  
      /**
       * 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
      {
          // TODO Support alternate renderers
          response.setContentType( "application/json" );
          return new JSonRenderer( response.getWriter() );
      }
  
      protected Object findResource( String path, Object root )
          throws Exception
      {
          return findResource( split( path ), root );
      }
 
     private String createMethod( String element, String accessor )
     {
         return accessor + Character.toUpperCase( element.charAt( 0 ) ) + element.substring( 1 );
     }
 
     private List<String> split( String path )
     {
         if ( path.startsWith( "/" ) )
         {
             path = path.substring( 1 );
         }
         List<String> elements = new ArrayList<String>();
         // Don't use String.split to support java 1.3 compatibility
         StringTokenizer tokenizer = new StringTokenizer( path, "/" );
         while ( tokenizer.hasMoreTokens() )
         {
             elements.add( tokenizer.nextToken() );
         }
         return elements;
     }
 
     private Object findResource( List<String> path, Object root )
         throws Exception
     {
         for ( Iterator<String> iterator = path.iterator(); iterator.hasNext(); )
         {
             String element = iterator.next();
 
             if ( root.getClass().isArray() )
             {
                 int index = Integer.parseInt( element );
                 root = Array.get( root, index );
                 continue;
             }
             if ( root instanceof List )
             {
                 int index = Integer.parseInt( element );
                 root = ( (List) root ).get( index );
                 continue;
             }
             if ( root instanceof Map )
             {
                 root = ( (Map) root ).get( element );
                 continue;
             }
 
             String get = createMethod( element, "get" );
             try
             {
                 root = invokeMethod( root, iterator, get );
             }
             catch ( NoSuchMethodException e )
             {
                 // Is this a method execution request ?
                 root = invokeMethod( root, iterator, element );
             }
 
             if ( root == null && iterator.hasNext() )
             {
                 throw new UnsupportedOperationException( "Unknown path" );
             }
         }
         return root;
     }
 
     private Object invokeMethod( Object root, Iterator<String> next, String name )
         throws Exception
     {
         Method method = findMethod( root, name );
         Class[] types = method.getParameterTypes();
         if ( types.length == 0 )
         {
             return method.invoke( root, null );
         }
         Object arg = convert( next.next(), types[0] );
         return method.invoke( root, new Object[] { arg } );
     }
 
     private final List<Class[]> parameterTypes = new ArrayList<Class[]>();
     {
         parameterTypes.add( new Class[0] );
         parameterTypes.add( new Class[] { String.class } );
         parameterTypes.add( new Class[] { String[].class } );
         parameterTypes.add( new Class[] { Class.class } );
         parameterTypes.add( new Class[] { Class[].class } );
     }
 
     private Method findMethod( Object root, String name )
         throws Exception
     {
         for ( Class[] parameterType : parameterTypes )
         {
             try
             {
                 return root.getClass().getMethod( name, parameterType );
             }
             catch ( NoSuchMethodException e )
             {
                 continue;
             }
         }
         throw new NoSuchMethodException( "no " + name + " method on object " + root.getClass() );
     }
 
     /**
      * @param arg
      * @param type expected type
      * @return
      */
     private Object convert( String arg, Class type )
     {
         if ( type.equals( String.class ) )
         {
             return arg;
         }
         if ( type.equals( Class.class ) )
         {
             return Monitoring.getRepository().getFeatureManager().getFeature( arg );
         }
         if ( type.isArray() )
         {
             StringTokenizer tokenizer = new StringTokenizer( arg, "+" );
             List args = new ArrayList();
             while ( tokenizer.hasMoreTokens() )
             {
                 args.add( convert( tokenizer.nextToken(), type.getComponentType() ) );
             }
             return args.toArray( (Object[]) Array
                 .newInstance( type.getComponentType(), args.size() ) );
         }
         return null;
     }
 
     private Collection<Class> parseFeatures( String element )
     {
         PluginManager manager = Monitoring.getRepository().getFeatureManager();
         Collection<Class> features = new ArrayList<Class>();
         StringTokenizer tokenizer = new StringTokenizer( element, "+" );
         while ( tokenizer.hasMoreTokens() )
         {
             Class feature = manager.getFeature( tokenizer.nextToken() );
             if ( feature != null )
             {
                 features.add( feature );
             }
         }
         return features;
     }
 }