/*
 * Copyright 2002,2004 The Apache Software Foundation.
 *
 * 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.apache.commons.jelly.tags.jetty;

import java.io.IOException;
import java.net.UnknownHostException;
import java.net.URL;

import org.apache.commons.jelly.JellyTagException;
import org.apache.commons.jelly.TagSupport;
import org.apache.commons.jelly.XMLOutput;
import org.apache.commons.logging.LogFactory;
import org.mortbay.http.HttpContext;
import org.mortbay.http.HttpListener;
import org.mortbay.http.HttpServer;
import org.mortbay.http.SocketListener;
import org.mortbay.http.UserRealm;
import org.mortbay.http.handler.NotFoundHandler;
import org.mortbay.http.handler.ResourceHandler;
import org.mortbay.util.Log;
import org.mortbay.util.MultiException;
import org.mortbay.util.OutputStreamLogSink;
import org.mortbay.util.Resource;

/**
 * Declare an instance of a Jetty http server
 *
 * @author  rtl
 * @version $Id: JettyHttpServerTag.java,v 1.3 2002/07/14 12:38:22 dion Exp $
 */
public class JettyHttpServerTag extends TagSupport {

    /** default port to create listeners for */
    public static final int DEFAULT_PORT = 8100;

    /** default host to create listeners/context for */
    public static final String DEFAULT_HOST = "localhost";

    /** default context to create context for */
    public static final String DEFAULT_CONTEXT_PATH = "/";

    /** default resource base to use for context */
    public static final String DEFAULT_RESOURCE_BASE = "./docRoot";

    /** default log file for Jetty */
    public static final String DEFAULT_LOG_FILE = "jetty.log";

    /** The Log to which logging calls will be made. */
    private static final org.apache.commons.logging.Log log =
        LogFactory.getLog(JettyHttpServerTag.class);

    /** the log sink for the Jety server */
    private static OutputStreamLogSink _logSink;

    // static initialisation
    {
        // setup a log for Jetty with a default filename
        try {
            _logSink = new OutputStreamLogSink(DEFAULT_LOG_FILE);
            //_logSink.start();
            Log.instance().add(_logSink);
        } catch (Exception ex ) {
            log.error(ex.getLocalizedMessage());
        }

    }

    /** unique identifier of the tag/ variable to store result in */
    private String _var;

    /** the http server for this tag */
    private HttpServer _server;

    /** filename of Jetty log file - with default */
    private String _logFileName = DEFAULT_LOG_FILE;

    /** Creates a new instance of JettyHttpServerTag */
    public JettyHttpServerTag() {

        // Create the server
        _server=new HttpServer();

        // turn off alias checking in Jetty's FileResource,
        // so that we don't need exact case in resource names
        System.setProperty("org.mortbay.util.FileResource.checkAliases", "false");
    }

    /**
     * Perform the tag functionality. In this case, create an http server after
     * making sure that it has at least one context and associated http handler,
     * creating defaults if it doesn't
     *
     * @param xmlOutput where to send output
     * @throws Exception when an error occurs
     */
    public void doTag(XMLOutput xmlOutput) throws JellyTagException {

        try {
            URL logFileURL = getContext().getResource(getLogFileName());
            _logSink.setFilename(logFileURL.getPath());
            _logSink.start();
        } catch (Exception ex ) {
            log.error(ex.getLocalizedMessage());
        }

        // allow nested tags first, e.g body
        invokeBody(xmlOutput);

        try {
            // if no listeners create a default port listener
            if (_server.getListeners().length == 0) {
                SocketListener listener=new SocketListener();
                listener.setPort(DEFAULT_PORT);
                listener.setHost(DEFAULT_HOST);
                _server.addListener(listener);
            }

            // if no context/s create a default context
            if (_server.getContexts().length == 0) {
                log.info("Creating a default context");
                // Create a context
                HttpContext context = _server.getContext(DEFAULT_HOST,
                                                        DEFAULT_CONTEXT_PATH);

                // Serve static content from the context
                URL baseResourceURL = getContext().getResource(DEFAULT_RESOURCE_BASE);
                Resource resource = Resource.newResource(baseResourceURL);
                context.setBaseResource(resource);
                _server.addContext(context);
            }
        }
        catch (UnknownHostException e) {
            throw new JellyTagException(e);
        }
        catch (IOException e) {
            throw new JellyTagException(e);
        }

        // check that all the contexts have at least one handler
        // if not then add a default resource handler and a not found handler
        HttpContext[] allContexts = _server.getContexts();
        for (int i = 0; i < allContexts.length; i++) {
            HttpContext currContext = allContexts[i];
            if (currContext.getHandlers().length == 0) {
                log.info("Adding resource and not found handlers to context:" +
                         currContext.getContextPath());
                currContext.addHandler(new ResourceHandler());
                currContext.addHandler(new NotFoundHandler());
            }
        }

        // Start the http server
        try {
            _server.start();
        }
        catch (MultiException e) {
            throw new JellyTagException(e);
        }

        // set variable to value if required
        if (getVar() != null) {
            getContext().setVariable(getVar(), _server);
        }
    }

    /**
     * Add an http listener to the server instance
     *
     * @param listener the listener to add
     */
    public void addListener(HttpListener listener) {
        _server.addListener(listener);
    }

    /**
     * Add an http context to the server instance
     *
     * @param context the context to add
     */
    public void addContext(HttpContext context) {
        _server.addContext(context);
    }

    /* ------------------------------------------------------------ */
    /**
     * Add a user authentication realm to the server instance
     *
     * @param realm the realm to add
     * @return the realm added
     */
    public UserRealm addRealm(UserRealm realm)
    {
        return _server.addRealm(realm);
    }

    //--------------------------------------------------------------------------
    // Property accessors/mutators
    //--------------------------------------------------------------------------

    /**
     * Getter for property var.
     *
     * @return Value of property var.
     */
    public String getVar() {
        return _var;
    }

    /**
     * Setter for property var.
     *
     * @param var New value of property var.
     */
    public void setVar(String var) {
        _var = var;
    }

    /**
     * Getter for property logFileName.
     *
     * @return Value of property logFileName.
     */
    public String getLogFileName() {
        return _logFileName;
    }

    /**
     * Setter for property logFileName.
     *
     * @param logFileName New value of property logFileName.
     */
    public void setLogFileName(String logFileName) {
        _logFileName = logFileName;
    }

}