/**
    * Copyright 2004-2014 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.kuali.rice.test.launch;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import javax.servlet.Servlet;
  
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.lang.builder.ToStringBuilder;
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.servlet.ServletContextHandler;
  import org.eclipse.jetty.servlet.ServletHolder;
  import org.eclipse.jetty.util.resource.ResourceCollection;
  import org.eclipse.jetty.webapp.WebAppContext;
  
  public class JettyLauncher {
  
      private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(JettyLauncher.class);
  
      /**
       * The name of an attribute we set in the ServletContext to indicate to the webapp
       * that it is running within unit tests, in case it needs to alter its configuration
       * or behavior.
       */
      public static final String JETTYSERVER_TESTMODE_ATTRIB = "JETTYSERVER_TESTMODE";
  
      private int port;
      private String contextName;
      private List<String> relativeWebappRoots = new ArrayList<String>();
      private Class<? extends Servlet> servletClass;
      private Server server;
      private ServletContextHandler context;
      private boolean failOnContextFailure;
  
      /**
       * Whether we are in test mode
       */
      private boolean testMode = false;
  
      public JettyLauncher() {
          this(8080);
      }
  
      public JettyLauncher(int port) {
          this(port, null, null, null);
      }
  
      public JettyLauncher(int port, String contextName) {
          this(port, contextName, null, null);
      }
  
      public JettyLauncher(int port, String contextName, String relativeWebappRoot) {
          this(port, contextName, relativeWebappRoot, null);
      }
  
      public JettyLauncher(int port, String contextName, Class<? extends Servlet> servletClass) {
          this(port, contextName, null, servletClass);
      }
  
      public JettyLauncher(int port, String contextName, String relativeWebappRoots, Class<? extends Servlet> servletClass) {
          this.port = port;
          this.contextName = contextName;
          StringTokenizer tokenizer = new StringTokenizer(relativeWebappRoots, ",");
          while (tokenizer.hasMoreTokens()) {
              String relativeWebappRoot = tokenizer.nextToken();
              this.relativeWebappRoots.add(relativeWebappRoot);
          }
          this.servletClass = servletClass;
      }
  
      public void setTestMode(boolean t) {
          this.testMode = t;
      }
  
      public boolean isTestMode() {
          return testMode;
      }
  
      public Server getServer() {
          return server;
      }
  
     public ServletContextHandler getContext() {
         return context;
     }
 
     public void start() throws Exception {
         server = createServer();
         server.start();
         if (isFailOnContextFailure() && contextStartupFailed()) {
             try {
                 server.stop();
             } catch (Exception e) {
                 LOG.warn("Failed to stop server after web application startup failure.");
             }
             throw new Exception("Failed to startup web application context!  Check logs for specific error.");
         }
     }
 
     public void stop() throws Exception {
         server.stop();
     }
 
     public boolean isStarted() {
         return server.isStarted();
     }
 
     protected Server createServer() {
         Server server = new Server(getPort());
         setBaseDirSystemProperty();
         if (useWebAppContext()) {
             File tmpDir = new File(System.getProperty("basedir") + "/target/jetty-tmp");
             tmpDir.mkdirs();
             WebAppContext webAppContext = new WebAppContext();
             webAppContext.setContextPath(getContextName());
             String[] fullRelativeWebappRoots = new String[this.relativeWebappRoots.size()];
             for (int i = 0; i < this.relativeWebappRoots.size(); i++) {
                 String fullRelativeWebappRoot = this.relativeWebappRoots.get(i);
                 fullRelativeWebappRoots[i] = System.getProperty("basedir") + fullRelativeWebappRoot;
                 if (LOG.isInfoEnabled()) {
                     LOG.info("WebAppRoot = " + fullRelativeWebappRoots[i]);
                 }
             }
             webAppContext.setBaseResource(new ResourceCollection(fullRelativeWebappRoots));
             webAppContext.setTempDirectory(tmpDir);
             webAppContext.setAttribute(JETTYSERVER_TESTMODE_ATTRIB, String.valueOf(isTestMode()));
             context = webAppContext;
             server.setHandler(context);
         } else {
             ServletContextHandler root = new ServletContextHandler(server,"/",ServletContextHandler.SESSIONS);
             root.addServlet(new ServletHolder(servletClass), getContextName());
             root.setAttribute(JETTYSERVER_TESTMODE_ATTRIB, String.valueOf(isTestMode()));
             context = root;
         }
         return server;
     }
 
     protected void setBaseDirSystemProperty() {
         if (System.getProperty("basedir") == null) {
             System.setProperty("basedir", System.getProperty("user.dir"));
         }
     }
 
     private boolean useWebAppContext() {
         return CollectionUtils.isNotEmpty(this.relativeWebappRoots);
     }
 
     protected boolean contextStartupFailed() throws Exception {
         return !context.isAvailable();
     }
 
     public String getContextName() {
         if (contextName == null) {
             return "/SampleRiceClient";
         }
         return contextName;
     }
 
     public void setContextName(String contextName) {
         this.contextName = contextName;
     }
 
     public int getPort() {
         return port;
     }
 
     public void setPort(int port) {
         this.port = port;
     }
 
 
     public boolean isFailOnContextFailure() {
         return this.failOnContextFailure;
     }
 
     public void setFailOnContextFailure(boolean failOnContextFailure) {
         this.failOnContextFailure = failOnContextFailure;
     }
 
     public String toString() {
         return new ToStringBuilder(this).append("port", port)
                 .append("contextName", contextName)
                 .append("relativeWebappRoots", relativeWebappRoots)
                 .append("servletClass", servletClass)
                 .toString();
     }
 
     public static void main(String[] args) {
         int port = args.length > 0 ? Integer.parseInt(args[0]) : 8080;
         String contextName = args.length > 1 ? args[1] : null;
         String relativeWebappRoot = args.length > 2 ? args[2] : null;
         try {
             new JettyLauncher(port, contextName, relativeWebappRoot).start();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }