/**
 * 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();
        }
    }
}