package org.apache.turbine;

/*
 * 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.
 */

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import jakarta.servlet.ServletConfig;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.MultipartConfig;
import jakarta.servlet.annotation.WebInitParam;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Unmarshaller;

import org.apache.commons.configuration2.Configuration;
import org.apache.commons.configuration2.PropertiesConfiguration;
import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
import org.apache.commons.configuration2.builder.combined.CombinedConfigurationBuilder;
import org.apache.commons.configuration2.builder.fluent.Parameters;
import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.commons.configuration2.io.HomeDirectoryLocationStrategy;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.turbine.modules.PageLoader;
import org.apache.turbine.pipeline.Pipeline;
import org.apache.turbine.pipeline.PipelineData;
import org.apache.turbine.pipeline.TurbinePipeline;
import org.apache.turbine.services.Initable;
import org.apache.turbine.services.InitializationException;
import org.apache.turbine.services.ServiceManager;
import org.apache.turbine.services.TurbineServices;
import org.apache.turbine.services.rundata.RunDataService;
import org.apache.turbine.services.template.TemplateService;
import org.apache.turbine.util.LocaleUtils;
import org.apache.turbine.util.RunData;
import org.apache.turbine.util.ServerData;
import org.apache.turbine.util.TurbineConfig;
import org.apache.turbine.util.TurbineException;
import org.apache.turbine.util.uri.URIConstants;

/**
 * <p>
 * Turbine is the main servlet for the entire system. If you need to perform
 * initialization of a service, then you should implement the Services API and
 * let your code be initialized by it.
 * </p>
 *
 * <p>
 * Turbine servlet recognizes the following initialization parameters.
 * </p>
 *
 * <ul>
 * <li><code>properties</code> the path to TurbineResources.properties file used
 * to configure Turbine, relative to the application root.</li>
 * <li><code>configuration</code> the path to TurbineConfiguration.xml file used
 * to configure Turbine from various sources, relative to the application
 * root.</li>
 * <li><code>applicationRoot</code> this parameter defaults to the web context
 * of the servlet container. You can use this parameter to specify the directory
 * within the server's filesystem, that is the base of your web
 * application.</li>
 * </ul>
 *
 * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
 * @author <a href="mailto:bmclaugh@algx.net">Brett McLaughlin</a>
 * @author <a href="mailto:greg@shwoop.com">Greg Ritter</a>
 * @author <a href="mailto:john.mcnally@clearink.com">John D. McNally</a>
 * @author <a href="mailto:frank.kim@clearink.com">Frank Y. Kim</a>
 * @author <a href="mailto:krzewski@e-point.pl">Rafal Krzewski</a>
 * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
 * @author <a href="mailto:sean@informage.net">Sean Legassick</a>
 * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
 * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
 * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
 * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
 * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
 * @version $Id$
 */
@WebServlet(name = "Turbine", urlPatterns = { "/app" }, loadOnStartup = 1, initParams = {
        @WebInitParam(name = TurbineConstants.APPLICATION_ROOT_KEY, value = TurbineConstants.APPLICATION_ROOT_DEFAULT),
        @WebInitParam(name = TurbineConfig.PROPERTIES_PATH_KEY, value = TurbineConfig.PROPERTIES_PATH_DEFAULT) })
@MultipartConfig
public class Turbine extends HttpServlet
{
    /** Serial version */
    private static final long serialVersionUID = -6317118078613623990L;

    /**
     * Name of path info parameter used to indicate the redirected stage of a
     * given user's initial Turbine request
     *
     * @deprecated
     */
    @Deprecated // not used
    public static final String REDIRECTED_PATHINFO_NAME = "redirected";

    /**
     * The base directory key @deprecated
     */
    @Deprecated // not used
    public static final String BASEDIR_KEY = "basedir";

    /**
     * In certain situations the init() method is called more than once,
     * sometimes even concurrently. This causes bad things to happen, so we use
     * this flag to prevent it.
     */
    private static boolean firstInit = true;

    /**
     * The pipeline to use when processing requests.
     */
    private static Pipeline pipeline = null;

    /** Whether init succeeded or not. */
    private static Throwable initFailure = null;

    /**
     * Should initialization activities be performed during doGet() execution?
     */
    private static boolean firstDoGet = true;

    /**
     * Keep all the properties of the web server in a convenient data structure
     */
    private static volatile ServerData serverData = null;

    /** The base from which the Turbine application will operate. */
    private static String applicationRoot;

    /** Servlet config for this Turbine webapp. */
    private static ServletConfig servletConfig;

    /** Servlet context for this Turbine webapp. */
    private static ServletContext servletContext;

    /**
     * The webapp root where the Turbine application is running in the servlet
     * container. This might differ from the application root.
     */
    private static String webappRoot;

    /** Our internal configuration object */
    private static Configuration configuration = null;

    /** Which configuration method is being used */
    private enum ConfigurationStyle
    {
        XML, PROPERTIES, JSON, YAML, UNSET
    }

    private static final Logger log = LogManager.getLogger(Turbine.class);

    /**
     * This init method will load the default resources from a properties file.
     *
     * This method is called by init(ServletConfig config)
     *
     * @throws ServletException
     *             a servlet exception.
     */
    @Override
    public void init() throws ServletException
    {
        synchronized (Turbine.class)
        {
            super.init();

            if (!firstInit)
            {
                log.info("Double initialization of Turbine was attempted!");
                return;
            }
            // executing init will trigger some static initializers, so we have
            // only one chance.
            firstInit = false;
            ServletConfig config = getServletConfig();

            try
            {
                ServletContext context = config.getServletContext();

                configure(config, context);

                TemplateService templateService = (TemplateService) getServiceManager().getService(TemplateService.SERVICE_NAME);
                if (templateService == null)
                {
                    throw new TurbineException("No Template Service configured!");
                }

                if (getRunDataService() == null)
                {
                    throw new TurbineException("No RunData Service configured!");
                }
            }
            catch (Throwable e)
            {
                // save the exception to complain loudly later :-)
                initFailure = e;
                log.fatal("Turbine: init() failed", e);
                throw new ServletException("Turbine: init() failed", e);
            }

            log.info("Turbine: init() Ready to Rumble!");
        }
    }

    /**
     * Read the master configuration file in, configure logging and start up any
     * early services.
     *
     * @param config
     *            The Servlet Configuration supplied by the container
     * @param context
     *            The Servlet Context supplied by the container
     *
     * @throws Exception
     *             A problem occurred while reading the configuration or
     *             performing early startup
     */

    protected void configure(ServletConfig config, ServletContext context)
            throws Exception
    {

        // Set the application root. This defaults to the webapp
        // context if not otherwise set.
        applicationRoot = findInitParameter(context, config,
                TurbineConstants.APPLICATION_ROOT_KEY,
                TurbineConstants.APPLICATION_ROOT_DEFAULT);

        webappRoot = context.getRealPath("/");
        // log.info("Web Application root is " + webappRoot);
        // log.info("Application root is " + applicationRoot);

        if (applicationRoot == null || applicationRoot.equals(TurbineConstants.WEB_CONTEXT))
        {
            applicationRoot = webappRoot;
            // log.info("got empty or 'webContext' Application root. Application
            // root now: " + applicationRoot);
        }

        // Set the applicationRoot for this webapp.
        setApplicationRoot(applicationRoot);

        //
        // Now we run the Turbine configuration code. There are two ways
        // to configure Turbine:
        //
        // a) By supplying an web.xml init parameter called "configuration"
        //
        // <init-param>
        // <param-name>configuration</param-name>
        // <param-value>/WEB-INF/conf/turbine.xml</param-value>
        // </init-param>
        //
        // This loads an XML based configuration file.
        //
        // b) By supplying an web.xml init parameter called "properties"
        //
        // <init-param>
        // <param-name>properties</param-name>
        // <param-value>/WEB-INF/conf/TurbineResources.properties</param-value>
        // </init-param>
        //
        // This loads a Properties based configuration file. Actually, these are
        // extended properties as provided by commons-configuration
        //
        // If neither a) nor b) is supplied, Turbine will fall back to the
        // known behaviour of loading a properties file called
        // /WEB-INF/conf/TurbineResources.properties relative to the
        // web application root.

        Path confPath = configureApplication(config, context);

        configureLogging(confPath);

        //
        // Logging with log4j 2 is done via convention, finding in path

        setTurbineServletConfig(config);
        setTurbineServletContext(context);

        getServiceManager().setApplicationRoot(applicationRoot);

        // We want to set a few values in the configuration so
        // that ${variable} interpolation will work for
        //
        // ${applicationRoot}
        // ${webappRoot}
        configuration.setProperty(TurbineConstants.APPLICATION_ROOT_KEY, applicationRoot);
        configuration.setProperty(TurbineConstants.WEBAPP_ROOT_KEY, webappRoot);

        getServiceManager().setConfiguration(configuration);

        // Initialize the service manager. Services
        // that have its 'earlyInit' property set to
        // a value of 'true' will be started when
        // the service manager is initialized.
        getServiceManager().init();

        // Retrieve the pipeline class and then initialize it. The pipeline
        // handles the processing of a webrequest/response cycle.
        String descriptorPath = configuration.getString(
                "pipeline.default.descriptor",
                TurbinePipeline.CLASSIC_PIPELINE);

        log.debug("Using descriptor path: {}", descriptorPath);

        // context resource path has to begin with slash, cft.
        // context.getResource
        if (!descriptorPath.startsWith("/"))
        {
            descriptorPath = "/" + descriptorPath;
        }

        try (InputStream reader = context.getResourceAsStream(descriptorPath))
        {
            JAXBContext jaxb = JAXBContext.newInstance(TurbinePipeline.class);
            Unmarshaller unmarshaller = jaxb.createUnmarshaller();
            pipeline = (Pipeline) unmarshaller.unmarshal(reader);
        }

        log.debug("Initializing pipeline");

        pipeline.initialize();
    }

    /**
     * Checks configuraton style, resolves the location of the configuration and
     * loads it to internal {@link Configuration} object
     * ({@link #configuration}).
     *
     * Allows reading from a {@link CombinedConfigurationBuilder} xml configuration file.
     *
     * @param config
     *            the Servlet Configuration
     * @param context
     *            Servlet Context
     * @return The resolved Configuration Path
     * @throws IOException
     *             if configuration path not found
     * @throws ConfigurationException
     *             if failed to configure
     */
    protected Path configureApplication(ServletConfig config, ServletContext context)
            throws IOException, ConfigurationException
    {
        ConfigurationStyle confStyle = ConfigurationStyle.UNSET;
        // first test
        String confFile = findInitParameter(context, config,
                TurbineConfig.CONFIGURATION_PATH_KEY,
                null);
        if (StringUtils.isNotEmpty(confFile))
        {
            confStyle = ConfigurationStyle.XML;
        }
        else // second test
        {
            confFile = findInitParameter(context, config,
                    TurbineConfig.PROPERTIES_PATH_KEY,
                    null);
            if (StringUtils.isNotEmpty(confFile))
            {
                confStyle = ConfigurationStyle.PROPERTIES;
            }
        }
        // more tests ..
        // last test
        if (confStyle == ConfigurationStyle.UNSET)
        { // last resort
            confFile = findInitParameter(context, config,
                    TurbineConfig.PROPERTIES_PATH_KEY,
                    TurbineConfig.PROPERTIES_PATH_DEFAULT);
            confStyle = ConfigurationStyle.PROPERTIES;
        }

        // First report
        log.debug("Loading configuration ({}) from {}", confStyle, confFile);

        // now begin loading
        Parameters params = new Parameters();
        File confPath = getApplicationRootAsFile();

        if (confFile.startsWith("/"))
        {
            confFile = confFile.substring(1); // cft. RFC2396 should not start
                                              // with a slash, if not absolute
                                              // path
        }

        Path confFileRelativePath = Paths.get(confFile);// relative to later
                                                        // join
        Path targetPath = Paths.get(confPath.toURI());
        targetPath = targetPath.resolve(confFileRelativePath);

        // Get the target path directory
        Path targetPathDirectory = targetPath.getParent();
        if (targetPathDirectory != null)
        {
            // set the configuration path
            confPath = targetPathDirectory.normalize().toFile();

            Path targetFilePath = targetPath.getFileName();
            if (targetFilePath != null)
            {
                // set the configuration file name
                confFile = targetFilePath.toString();
            }

        }

        switch (confStyle)
        {
            case XML:
                // relative base path used for this and child configuration
                // files
                CombinedConfigurationBuilder combinedBuilder = new CombinedConfigurationBuilder()
                        .configure(params.fileBased()
                                .setFileName(confFile)
                                .setListDelimiterHandler(new DefaultListDelimiterHandler(','))
                                .setLocationStrategy(new HomeDirectoryLocationStrategy(confPath.getCanonicalPath(), false)));
                configuration = combinedBuilder.getConfiguration();
                break;

            case PROPERTIES:
                FileBasedConfigurationBuilder<PropertiesConfiguration> propertiesBuilder = new FileBasedConfigurationBuilder<>(
                        PropertiesConfiguration.class)
                                .configure(params.properties()
                                        .setFileName(confFile)
                                        .setListDelimiterHandler(new DefaultListDelimiterHandler(','))
                                        .setLocationStrategy(new HomeDirectoryLocationStrategy(confPath.getCanonicalPath(), false)));
                // meta configuration: this may contain any commons configuration: system<>, jndi, env
                configuration = propertiesBuilder.getConfiguration();
                break;
            case JSON:
            case YAML:
                throw new NotImplementedException("JSON or XAML configuration style not yet implemented!");

            default:
                break;
        }
        // Now report our successful configuration to the world
        log.info("Loaded configuration ({}) from {} style: {}",
                confStyle, confFile, configuration.toString());

        return targetPath;
    }

    /**
     * Finds the specified servlet configuration/initialization parameter,
     * looking first for a servlet-specific parameter, then for a global
     * parameter, and using the provided default if not found.
     *
     * @param context
     *            the servlet context
     * @param config
     *            configuration object
     * @param name
     *            name of parameter
     * @param defaultValue
     *            of the parameter
     * @return String value of the parameter
     */
    protected String findInitParameter(ServletContext context,
            ServletConfig config, String name, String defaultValue)
    {
        String path = null;
        String parameterName = name;

        // Try the name as provided first.
        boolean usingNamespace = parameterName.startsWith(TurbineConstants.CONFIG_NAMESPACE);
        while (true)
        {
            path = config.getInitParameter(parameterName);
            if (StringUtils.isEmpty(path))
            {
                path = context.getInitParameter(parameterName);
                if (StringUtils.isEmpty(path))
                {
                    // The named parameter didn't yield a value.
                    if (usingNamespace)
                    {
                        path = defaultValue;
                    }
                    else
                    {
                        // Try again using Turbine's namespace.
                        parameterName = TurbineConstants.CONFIG_NAMESPACE + '.' + parameterName;
                        usingNamespace = true;
                        continue;
                    }
                }
            }
            break;
        }

        return path;
    }

    /**
     * Initializes the services which need <code>PipelineData</code> to
     * initialize themselves (post startup).
     *
     * @param data
     *            The first <code>GET</code> request.
     */
    public void init(PipelineData data)
    {
        synchronized (Turbine.class)
        {
            if (firstDoGet)
            {
                // All we want to do here is save some servlet
                // information so that services and processes
                // that don't have direct access to a RunData
                // object can still know something about
                // the servlet environment.
                saveServletInfo(data);

                // Initialize services with the PipelineData instance
                TurbineServices services = (TurbineServices) getServiceManager();

                for (Iterator<String> i = services.getServiceNames(); i.hasNext();)
                {
                    String serviceName = i.next();
                    Object service = services.getService(serviceName);

                    if (service instanceof Initable)
                    {
                        try
                        {
                            ((Initable) service).init(data);
                        }
                        catch (InitializationException e)
                        {
                            log.warn("Could not initialize Initable {} with PipelineData", serviceName, e);
                        }
                    }
                }

                // Mark that we're done.
                firstDoGet = false;
                log.info("Turbine: first Request successful");
            }
        }
    }

    /**
     * Return the current configuration with all keys included
     *
     * @return a Configuration Object
     */
    public static Configuration getConfiguration()
    {
        return configuration;
    }

    /**
     * Return the server name.
     *
     * @return String server name
     */
    public static String getServerName()
    {
        return getDefaultServerData().getServerName();
    }

    /**
     * Return the server scheme.
     *
     * @return String server scheme
     */
    public static String getServerScheme()
    {
        return getDefaultServerData().getServerScheme();
    }

    /**
     * Return the server port.
     *
     * @return String server port
     */
    public static String getServerPort()
    {
        return Integer.toString(getDefaultServerData().getServerPort());
    }

    /**
     * Get the script name. This is the initial script name. Actually this is
     * probably not needed any more. I'll check. jvz.
     *
     * @return String initial script name.
     */
    public static String getScriptName()
    {
        return getDefaultServerData().getScriptName();
    }

    /**
     * Return the context path.
     *
     * @return String context path
     */
    public static String getContextPath()
    {
        return getDefaultServerData().getContextPath();
    }

    /**
     * Return all the Turbine Servlet information (Server Name, Port, Scheme in
     * a ServerData structure. This is generated from the values set when
     * initializing the Turbine and may not be correct if you're running in a
     * clustered structure. You can provide default values in your configuration
     * for cases where access is requied before your application is first
     * accessed by a user. This might be used if you need a DataURI and have no
     * RunData object handy.
     *
     * @return An initialized ServerData object
     */
    public static ServerData getDefaultServerData()
    {
        if (serverData == null)
        {
            String serverName = configuration.getString(TurbineConstants.DEFAULT_SERVER_NAME_KEY);
            if (serverName == null)
            {
                log.error("ServerData Information requested from Turbine before first request!");
            }
            else
            {
                log.info("ServerData Information retrieved from configuration.");
            }
            // Will be overwritten once the first request is run;
            serverData = new ServerData(serverName,
                    configuration.getInt(TurbineConstants.DEFAULT_SERVER_PORT_KEY,
                            URIConstants.HTTP_PORT),
                    configuration.getString(TurbineConstants.DEFAULT_SERVER_SCHEME_KEY,
                            URIConstants.HTTP),
                    configuration.getString(TurbineConstants.DEFAULT_SCRIPT_NAME_KEY),
                    configuration.getString(TurbineConstants.DEFAULT_CONTEXT_PATH_KEY));
        }
        return serverData;
    }

    /**
     * Set the servlet config for this turbine webapp.
     *
     * @param config
     *            New servlet config
     */
    public static void setTurbineServletConfig(ServletConfig config)
    {
        servletConfig = config;
    }

    /**
     * Get the servlet config for this turbine webapp.
     *
     * @return ServletConfig
     */
    public static ServletConfig getTurbineServletConfig()
    {
        return servletConfig;
    }

    /**
     * Set the servlet context for this turbine webapp.
     *
     * @param context
     *            New servlet context.
     */
    public static void setTurbineServletContext(ServletContext context)
    {
        servletContext = context;
    }

    /**
     * Get the servlet context for this turbine webapp.
     *
     * @return ServletContext
     */
    public static ServletContext getTurbineServletContext()
    {
        return servletContext;
    }

    /**
     * The <code>Servlet</code> destroy method. Invokes
     * <code>ServiceBroker</code> tear down method.
     */
    @Override
    public void destroy()
    {
        // Shut down all Turbine Services.
        getServiceManager().shutdownServices();

        firstInit = true;
        firstDoGet = true;
        log.info("Turbine: Done shutting down!");
    }

    /**
     * The primary method invoked when the Turbine servlet is executed.
     *
     * @param req
     *            Servlet request.
     * @param res
     *            Servlet response.
     * @throws IOException
     *             a servlet exception.
     * @throws ServletException
     *             a servlet exception.
     */
    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException
    {
        // Check to make sure that we started up properly.
        if (initFailure != null)
        {
            handleHorribleException(res, initFailure);
            return;
        }

        // Get general PipelineData here...
        try (PipelineData pipelineData = getRunDataService().getRunData(req, res, getServletConfig()))
        {
            try
            {
                // Perform turbine specific initialization below.
                Map<Class<?>, Object> runDataMap = new HashMap<>();
                runDataMap.put(RunData.class, pipelineData);
                // put the data into the pipeline
                pipelineData.put(RunData.class, runDataMap);

                // If this is the first invocation, perform some
                // initialization. Certain services need RunData to initialize
                // themselves.
                if (firstDoGet)
                {
                    init(pipelineData);
                }

                // Stages of Pipeline implementation execution
                // configurable via attached Valve implementations in a
                // XML properties file.
                pipeline.invoke(pipelineData);
            }
            catch (Throwable t)
            {
                handleException(pipelineData, res, t);
            }
        }
        catch (Throwable t)
        {
            handleHorribleException(res, t);

        }
    }

    /**
     * In this application doGet and doPost are the same thing.
     *
     * @param req
     *            Servlet request.
     * @param res
     *            Servlet response.
     * @throws IOException
     *             a servlet exception.
     * @throws ServletException
     *             a servlet exception.
     */
    @Override
    public void doPost(HttpServletRequest req, HttpServletResponse res)
            throws IOException, ServletException
    {
        doGet(req, res);
    }

    /**
     * Return the servlet info.
     *
     * @return a string with the servlet information.
     */
    @Override
    public String getServletInfo()
    {
        return "Turbine Servlet";
    }

    /**
     * This method is about making sure that we catch and display errors to the
     * screen in one fashion or another. What happens is that it will attempt to
     * show the error using your user defined Error Screen. If that fails, then
     * it will resort to just displaying the error and logging it all over the
     * place including the servlet engine log file, the Turbine log file and on
     * the screen.
     *
     * @param pipelineData
     *            A Turbine PipelineData object.
     * @param res
     *            Servlet response.
     * @param t
     *            The exception to report.
     */
    protected void handleException(PipelineData pipelineData, HttpServletResponse res,
            Throwable t)
    {
        RunData data = (RunData) pipelineData;
        // make sure that the stack trace makes it the log
        log.error("Turbine.handleException: ", t);

        try
        {
            // This is where we capture all exceptions and show the
            // Error Screen.
            data.setStackTrace(ExceptionUtils.getStackTrace(t), t);

            // setup the screen
            data.setScreen(configuration.getString(
                    TurbineConstants.SCREEN_ERROR_KEY,
                    TurbineConstants.SCREEN_ERROR_DEFAULT));

            // do more screen setup for template execution if needed
            if (data.getTemplateInfo() != null)
            {
                data.getTemplateInfo()
                        .setScreenTemplate(configuration.getString(
                                TurbineConstants.TEMPLATE_ERROR_KEY,
                                TurbineConstants.TEMPLATE_ERROR_VM));
            }

            // Make sure to not execute an action.
            data.setAction("");

            PageLoader.getInstance().exec(pipelineData,
                    configuration.getString(TurbineConstants.PAGE_DEFAULT_KEY,
                            TurbineConstants.PAGE_DEFAULT_DEFAULT));

            data.getResponse().setContentType(data.getContentType());
            data.getResponse().setStatus(data.getStatusCode());
        }
        // Attempt to do *something* at this point...
        catch (Throwable reallyScrewedNow)
        {
            handleHorribleException(res, reallyScrewedNow);
        }
    }

    /**
     * This method handles exception cases where no PipelineData object exists
     *
     * @param res
     *            Servlet response.
     * @param t
     *            The exception to report.
     */
    protected void handleHorribleException(HttpServletResponse res, Throwable t)
    {
        try
        {
            res.setContentType(TurbineConstants.DEFAULT_TEXT_CONTENT_TYPE);
            res.setStatus(200);
            PrintWriter writer = res.getWriter();
            writer.println("Horrible Exception: ");
            t.printStackTrace(writer);
        }
        catch (Exception ignored)
        {
            // ignore
        }

        log.error(t.getMessage(), t);
    }

    /**
     * Save some information about this servlet so that it can be utilized by
     * object instances that do not have direct access to PipelineData.
     *
     * @param data
     *            Turbine request data
     */
    public static synchronized void saveServletInfo(PipelineData data)
    {
        // Store the context path for tools like ContentURI and
        // the UIManager that use webapp context path information
        // for constructing URLs.

        //
        // Bundle all the information above up into a convenient structure
        //
        ServerData requestServerData = data.get(Turbine.class, ServerData.class);
        serverData = (ServerData) requestServerData.clone();
    }

    /**
     * Checks Log4j 2 Context, loads log4File, if configured and configuration
     * is not already located.
     *
     * @param logConf
     *            Configuration file path
     * @throws IOException
     *             if path not found
     */
    protected void configureLogging(Path logConf) throws IOException
    {
        LoggerContext context = (LoggerContext) LogManager.getContext(false);

        if (context.getConfiguration().getConfigurationSource().getLocation() == null)
        {
            Path log4jFile = resolveLog4j2(logConf.getParent());
            // configured + no other log4j configuration already found
            if (log4jFile != null)
            {
                org.apache.logging.log4j.spi.LoggerContext ctxContext = LogManager.getContext(null, false, log4jFile.toUri());
                if (ctxContext instanceof LoggerContext) {
                    log.info("resolved log4j2 location: {}", context.getConfiguration().getConfigurationSource().getLocation());
                }
                
            }
        }
        log.info("found log4j2 location: {}", context.getConfiguration().getConfigurationSource().getLocation());
    }

    /**
     * Check {@linkplain TurbineConstants#LOG4J2_CONFIG_FILE} in Turbine
     * configuration.
     *
     * @param logConfPath
     *            configuration directory
     * @return Resolved log4j2 {@link Path} or null, if not found or configured
     *         "none".
     */
    protected Path resolveLog4j2(Path logConfPath)
    {
        String log4jFile = configuration.getString(TurbineConstants.LOG4J2_CONFIG_FILE,
                TurbineConstants.LOG4J2_CONFIG_FILE_DEFAULT);

        if (log4jFile.startsWith("/"))
        {
            log4jFile = log4jFile.substring(1);
        }
        Path log4jTarget = null;
        if (StringUtils.isNotEmpty(log4jFile) && !log4jFile.equalsIgnoreCase("none"))
        {
            // log4j must either share path with configuration path or resolved
            // relatively

            if (logConfPath != null)
            {
                Path log4jFilePath = Paths.get(log4jFile);
                Path logFilePath = logConfPath.resolve(log4jFilePath);
                if (logFilePath != null && logFilePath.toFile().exists())
                {
                    log4jTarget = logFilePath.normalize();
                }
                else
                {
                    // fall back just using the filename, if path match
                    if (log4jFilePath != null && log4jFilePath.getParent() != null && logConfPath.endsWith(log4jFilePath.getParent()))
                    {
                        logFilePath = logConfPath.resolve(log4jFilePath.getFileName());
                        if (logFilePath != null && logFilePath.toFile().exists())
                        {
                            log4jTarget = logFilePath.normalize();
                        }
                    }
                }
            }
        }
        return log4jTarget;
    }

    /**
     * Set the application root for the webapp.
     *
     * @param val
     *            New app root.
     */
    public static void setApplicationRoot(String val)
    {
        applicationRoot = val;
    }

    /**
     * Get the application root for this Turbine webapp.
     *
     * @return String applicationRoot
     */
    public static String getApplicationRoot()
    {
        return applicationRoot;
    }

    /**
     * Get the application root for this Turbine webapp as a file object.
     *
     * @return File applicationRootFile
     */
    public static File getApplicationRootAsFile()
    {
        return new File(applicationRoot);
    }

    /**
     * Used to get the real path of configuration and resource information. This
     * can be used by an app being developed in a standard CVS layout.
     *
     * @param path
     *            path translated to the application root
     * @return the real path
     */
    public static String getRealPath(String path)
    {
        if (path.startsWith("/"))
        {
            return new File(getApplicationRootAsFile(), path.substring(1)).getAbsolutePath();
        }

        return new File(getApplicationRootAsFile(), path).getAbsolutePath();
    }

    /**
     * Return an instance of the currently configured Service Manager
     *
     * @return A service Manager instance
     */
    private ServiceManager getServiceManager()
    {
        return TurbineServices.getInstance();
    }

    /**
     * Returns the default input encoding for the servlet.
     *
     * @return the default input encoding.
     *
     * @deprecated Use
     *             {@link org.apache.turbine.pipeline.DefaultSetEncodingValve}
     *             to set default encoding
     */
    @Deprecated
    public static String getDefaultInputEncoding()
    {
        return LocaleUtils.getDefaultInputEncoding();
    }

    /**
     * Static Helper method for looking up the RunDataService
     *
     * @return A RunDataService
     */
    private RunDataService getRunDataService()
    {
        return (RunDataService) getServiceManager().getService(RunDataService.SERVICE_NAME);
    }
}
