package net.sf.tacos.rest;
   
   import java.net.URL;
   import java.net.MalformedURLException;
   import java.io.File;
   import java.io.IOException;
   import java.util.Set;
   import java.util.Map;
   import javax.servlet.http.HttpServlet;
  import javax.servlet.ServletContext;
  
  import org.apache.tapestry.INamespace;
  import org.apache.tapestry.Tapestry;
  import org.apache.tapestry.engine.ServiceEncoder;
  import org.apache.tapestry.engine.ServiceEncoding;
  import org.apache.tapestry.services.ServiceConstants;
  import org.apache.tapestry.services.ApplicationInitializer;
  import org.apache.commons.collections.FastHashMap;
  
  import org.scannotation.AnnotationDB;
  
  /**
   * Rest-style encoder for pages.<p/> The urls generated and understood are of the form
   * /view/pagename (so, you'll have to register a servlet mapping for /view in web.xml).
   * <p/>
   * If page classes have a {@link UriTemplate} annotation, upon initialization this service 
   * will scan, gather and use those mappings for url generation (instead of the pagename).
   */
  public class RestPageEncoder implements ServiceEncoder, ApplicationInitializer {
  
      private String url;
      private boolean caseSensitive;
  
      private Map<String, String> pathToPageMap;
      private Map<String, String> pageToPathMap;
  
      public void encode(ServiceEncoding encoding) {
          String service = encoding.getParameterValue(ServiceConstants.SERVICE);
  
          if (!service.equals(Tapestry.PAGE_SERVICE)) {
              return;
          }
  
          String pageName = encoding.getParameterValue(ServiceConstants.PAGE);
  
          // Only handle pages in the application namespace (not from a library).
          if (pageName.indexOf(INamespace.SEPARATOR) >= 0) {
              return;
          }
  
          StringBuffer buffer = new StringBuffer(url);
          buffer.append('/');
          String pathOverride = pageToPathMap.get(pageName);
          if (pathOverride != null) {
              buffer.append(pathOverride);
          } else {
              buffer.append(pageName);
          }
  
          encoding.setServletPath(buffer.toString());
          encoding.setParameterValue(ServiceConstants.SERVICE, null);
          encoding.setParameterValue(ServiceConstants.PAGE, null);
      }
  
      public void decode(ServiceEncoding encoding) {
          String servletPath = encoding.getServletPath();
  
          if (!servletPath.startsWith(url)) {
              return;
          }
  
          // handle only if there's path info
          if (encoding.getPathInfo()==null) {
              return;
          }
  
          // Skip the slash and the dot.
          String page = encoding.getPathInfo().substring(1);
  
          String pageOverride = caseSensitive ?
                  pathToPageMap.get(page) : pathToPageMap.get(page.toLowerCase());
          if (pageOverride != null) {
              page = pageOverride;
          }
  
          encoding.setParameterValue(ServiceConstants.SERVICE, Tapestry.PAGE_SERVICE);
          encoding.setParameterValue(ServiceConstants.PAGE, page);
      }
  
      public void setUrl(String url) {
          this.url = url;
      }
  
      public void setCaseSensitive(boolean caseSensitive) {
          this.caseSensitive = caseSensitive;
      }
  
      public void initialize(HttpServlet servlet) {
          FastHashMap pageToPath = new FastHashMap();
         FastHashMap pathToPage = new FastHashMap();
 
         URL webInfClasses = findWebInfClassesPath(servlet.getServletContext());
 
         scan(pageToPath, pathToPage, webInfClasses);
 
         storeMaps(pageToPath, pathToPage);
     }
 
     private void scan(FastHashMap pageToPath, FastHashMap pathToPage, URL url) {
         if (url == null)
             return;
 
         AnnotationDB db = new AnnotationDB();
         db.addIgnoredPackages("org");
         try {
             db.scanArchives(url);
         } catch (IOException e) {
             return;
         }
 
         Set<String> simpleClasses = db.getAnnotationIndex().get(UriTemplate.class.getName());
         if (simpleClasses == null)
             return;
 
         for (String simpleClass : simpleClasses) {
             UriTemplate uriTemplate;
             try {
                 uriTemplate = Class.forName(simpleClass).getAnnotation(UriTemplate.class);
             } catch (ClassNotFoundException e) {
                 continue;
             }
 
             String path = uriTemplate.value();
             if (path.startsWith("/")) {
                 path = path.substring(1);
             }
             if (!caseSensitive) {
                 path = path.toLowerCase();
             }
 
             String page = toPage(simpleClass);
             pathToPage.put(path, page);
             pageToPath.put(page, path);
 
             // now process aliases
             for (String aliasPath : uriTemplate.alias()) {
                 pathToPage.put(aliasPath, page);
             }
 
         }
     }
 
     @SuppressWarnings("unchecked")
     private void storeMaps(FastHashMap pageToPath, FastHashMap pathToPage) {
         pageToPath.setFast(true);
         pathToPage.setFast(true);
         pageToPathMap = pageToPath;
         pathToPageMap = pathToPage;
     }
 
     /**
      * Given the classname, returns the tapestry page name.
      * TODO: assumes parent package is pages, better use tap. configuration of page packages
      * @param className
      * @return
      */
     private String toPage(String className) {
         int pos = className.indexOf(".pages.");
         return className.substring(pos + 7).replace('.', '/');
     }
 
     private URL findWebInfClassesPath(ServletContext servletContext) {
         String path = servletContext.getRealPath("/WEB-INF/classes");
         if (path == null) return null;
         File fp = new File(path);
         if (!fp.exists()) return null;
         try {
             return fp.toURI().toURL();
         }
         catch (MalformedURLException e) {
             throw new RuntimeException(e);
         }
     }
 }