/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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.apache.commons.jci.examples.serverpages;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.lang.String;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.jci.ReloadingClassLoader;
  import org.apache.commons.jci.compilers.CompilationResult;
  import org.apache.commons.jci.compilers.JavaCompilerFactory;
  import org.apache.commons.jci.listeners.CompilingListener;
  import org.apache.commons.jci.monitor.FilesystemAlterationMonitor;
  import org.apache.commons.jci.monitor.FilesystemAlterationObserver;
  import org.apache.commons.jci.problems.CompilationProblem;
  import org.apache.commons.jci.readers.ResourceReader;
  import org.apache.commons.jci.stores.MemoryResourceStore;
  import org.apache.commons.jci.stores.TransactionalResourceStore;
  import org.apache.commons.jci.utils.ConversionUtils;
  
  
  /**
   * A mini JSP servlet that monitors a certain directory and
   * recompiles and then instantiates the JSP pages as soon as
   * they have changed.
   *
   * @author tcurdt
   */
  public final class ServerPageServlet extends HttpServlet {
  
      private static final long serialVersionUID = 1L;
  
      private final ReloadingClassLoader classloader = new ReloadingClassLoader(ServerPageServlet.class.getClassLoader());
      private FilesystemAlterationMonitor fam;
      private CompilingListener jspListener; 
  
      private Map<String, HttpServlet> servletsByClassname = new HashMap<String, HttpServlet>();
  
      public void init() throws ServletException {
          super.init();
  
          final File serverpagesDir = new File(getServletContext().getRealPath("/") + getInitParameter("serverpagesDir"));
  
          log("Monitoring serverpages in " + serverpagesDir);
  
          final TransactionalResourceStore store = new TransactionalResourceStore(new MemoryResourceStore()) {
  
              private Set<String> newClasses;
              private Map<String, HttpServlet> newServletsByClassname;
  
              public void onStart() {
                  super.onStart();
  
                  newClasses = new HashSet<String>();
                  newServletsByClassname = new HashMap<String, HttpServlet>(servletsByClassname);
              }
  
              public void onStop() {
                  super.onStop();
  
                  boolean reload = false;
                  for (String clazzName : newClasses) {
                      try {
                          final Class clazz = classloader.loadClass(clazzName);
  
                          if (!HttpServlet.class.isAssignableFrom(clazz)) {
                              log(clazzName + " is not a servlet");
                              continue;
                          }
  
                          // create new instance of jsp page
                          final HttpServlet servlet = (HttpServlet) clazz.newInstance();
                          newServletsByClassname.put(clazzName, servlet);
  
                         reload = true;
                     } catch(Exception e) {
                         log("", e);
                     }
                 }
 
                 if (reload) {
                     log("Activating new map of servlets "+ newServletsByClassname);
                     servletsByClassname = newServletsByClassname;
                 }
             }
 
             public void write(String pResourceName, byte[] pResourceData) {
                 super.write(pResourceName, pResourceData);
 
                 if (pResourceName.endsWith(".class")) {
 
                     // compiler writes a new class, remember the classes to reload
                     newClasses.add(pResourceName.replace('/', '.').substring(0, pResourceName.length() - ".class".length()));
                 }
             }
 
         };
 
         // listener that generates the java code from the jsp page and provides that to the compiler
         jspListener = new CompilingListener(new JavaCompilerFactory().createCompiler("eclipse"), store) {
 
             private final JspGenerator transformer = new JspGenerator();
             private final Map<String, byte[]> sources = new HashMap<String, byte[]>();
             private final Set<String> resourceToCompile = new HashSet<String>();
 
             public void onStart(FilesystemAlterationObserver pObserver) {
                 super.onStart(pObserver);
 
                 resourceToCompile.clear();
             }
 
 
             public void onFileChange(File pFile) {
                 if (pFile.getName().endsWith(".jsp")) {
                     final String resourceName = ConversionUtils.stripExtension(getSourceNameFromFile(observer, pFile)) + ".java";
 
                     log("Updating " + resourceName);
 
                     sources.put(resourceName, transformer.generateJavaSource(resourceName, pFile));
 
                     resourceToCompile.add(resourceName);
                 }
                 super.onFileChange(pFile);
             }
 
 
             public void onFileCreate(File pFile) {
                 if (pFile.getName().endsWith(".jsp")) {
                     final String resourceName = ConversionUtils.stripExtension(getSourceNameFromFile(observer, pFile)) + ".java";
 
                     log("Creating " + resourceName);
 
                     sources.put(resourceName, transformer.generateJavaSource(resourceName, pFile));
 
                     resourceToCompile.add(resourceName);
                 }
                 super.onFileCreate(pFile);
             }
 
 
             public String[] getResourcesToCompile(FilesystemAlterationObserver pObserver) {
                 // we only want to compile the jsp pages
                 final String[] resourceNames = new String[resourceToCompile.size()];
                 resourceToCompile.toArray(resourceNames);
                 return resourceNames;
             }
 
 
             public ResourceReader getReader( final FilesystemAlterationObserver pObserver ) {
                 return new JspReader(sources, super.getReader(pObserver));
             }
         };
         jspListener.addReloadNotificationListener(classloader);
         
         fam = new FilesystemAlterationMonitor();
         fam.addListener(serverpagesDir, jspListener);
         fam.start();
     }
 
     private String convertRequestToServletClassname( final HttpServletRequest request ) {
 
         String path = request.getPathInfo().substring(1);
 
         return ConversionUtils.stripExtension(path).replace('/', '.');
     }
 
     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
         log("Request " + request.getRequestURI());
 
         final CompilationResult result = jspListener.getCompilationResult();
         final CompilationProblem[] errors = result.getErrors();
 
         if (errors.length > 0) {
 
             // if there are errors we provide the compilation errors instead of the jsp page
 
             final PrintWriter out = response.getWriter();
 
             out.append("<html><body>");
 
             for (CompilationProblem problem : errors) {
                 out.append(problem.toString()).append("<br/>").append('\n');
             }
 
             out.append("</body></html>");
 
             out.flush();
             out.close();
             return;
         }
 
         final String servletClassname = convertRequestToServletClassname(request);
 
         log("Checking for serverpage " + servletClassname);
 
         final HttpServlet servlet = servletsByClassname.get(servletClassname);
 
         if (servlet == null) {
             log("No servlet  for " + request.getRequestURI());
             response.sendError(404);
             return;
         }
 
         log("Delegating request to " + servletClassname);
 
         servlet.service(request, response);
     }
 
     public void destroy() {
 
         fam.stop();
 
         super.destroy();
     }
 }