package org.andromda.templateengines.freemarker;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.andromda.core.common.AndroMDALogger;
import org.andromda.core.common.ExceptionUtils;
import org.andromda.core.templateengine.TemplateEngine;
import org.andromda.core.templateengine.TemplateEngineException;
import org.apache.log4j.Appender;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import freemarker.template.Configuration;
import freemarker.template.ObjectWrapper;
import freemarker.template.Template;

/**
 * The TemplateEngine implementation for the FreeMarker template processor.
 *
 * @author Chad Brandon
 * @author Olaf Muliawan
 * @author Matthias Bohlen (usage of context classloader so that it works in Maven environments)
 * @see <a href="http://www.freemarker.org">Freemarker</a>
 */
public class FreeMarkerTemplateEngine implements TemplateEngine
{
    /**
     * @see org.andromda.core.templateengine.TemplateEngine#initialize(String)
     */
    public void initialize(String namespace) throws Exception
    {
        this.initLogger(namespace);
    }

    /**
     * The main Configuration object of Freemarker.
     */
    protected Configuration configuration = null;

    /**
     * @see org.andromda.core.templateengine.TemplateEngine#processTemplate(String,
     *      java.util.Map, java.io.Writer)
     */
    public void processTemplate(String templateFile, Map<String, Object> templateObjects, Writer output) throws Exception
    {
        ExceptionUtils.checkEmpty("templateFile", templateFile);
        ExceptionUtils.checkNull("output", output);

        if (this.configuration == null)
        {
            this.configuration = new Configuration();

            // tell FreeMarker it should use the ContextClassLoader when
            // searching for templates
            this.configuration.setTemplateLoader(new ContextResourceLoader());

            // use Bean Wrapper, in order to get maximal reflection
            // capabilities
            this.configuration.setObjectWrapper(ObjectWrapper.BEANS_WRAPPER);
        }

        // create the template
        final Template template = this.configuration.getTemplate(templateFile);

        if (templateObjects == null)
        {
            templateObjects = new HashMap<String, Object>();
        }

        // - merge data model with template
        template.process(templateObjects, output);
    }

    /**
     * Template loader which accesses the context classloader because otherwise
     * templates will not be found properly in a multi-classloader environment.
     */
    private static class ContextResourceLoader extends freemarker.cache.URLTemplateLoader
    {
        protected URL getURL(String name)
        {
            return Thread.currentThread().getContextClassLoader().getResource(name);
        }
    }

    /**
     * @see org.andromda.core.templateengine.TemplateEngine#shutdown()
     */
    public void shutdown()
    {
        this.shutdownLogger();
        this.configuration = null;
    }

    /**
     * Stores the macro libraries the template.
     */
    private List<String> macroLibraries = new ArrayList<String>();

    /**
     * @see org.andromda.core.templateengine.TemplateEngine#getMacroLibraries()
     */
    public List<String> getMacroLibraries()
    {
        return this.macroLibraries;
    }

    /**
     * @see org.andromda.core.templateengine.TemplateEngine#addMacroLibrary(String)
     */
    public void addMacroLibrary(String macroLibrary)
    {
        this.macroLibraries.add(macroLibrary);
    }

    /**
     * @see org.andromda.core.templateengine.TemplateEngine#setMergeLocation(String)
     */
    public void setMergeLocation(String mergeLocation)
    {
    }

    /**
     * The name of the temporary string template.
     */
    private static final String STRING_TEMPLATE = "stringTemplate";

    /**
     * @see org.andromda.core.templateengine.TemplateEngine#getEvaluatedExpression(String,
     *      java.util.Map)
     */
    public String getEvaluatedExpression(final String expression, Map<String, Object> templateObjects)
    {
        try
        {
            // - create the template
            final Template template = new Template(STRING_TEMPLATE, new StringReader(expression), new Configuration());

            if (templateObjects == null)
            {
                templateObjects = new HashMap<String, Object>();
            }

            final StringWriter output = new StringWriter();

            // - merge data model with template
            template.process(templateObjects, output);

            return output.toString();
        }
        catch (final Throwable throwable)
        {
            throw new TemplateEngineException(throwable);
        }
    }

    /**
     * null logger
     */
    protected static Logger logger = null;

    /**
     * Opens a log file for this plugin.
     *
     * @throws IOException
     *             if the file cannot be opened
     */
    private void initLogger(String pluginName) throws IOException
    {
        logger = AndroMDALogger.getNamespaceLogger(pluginName);
        logger.setAdditivity(false);
        FileAppender appender = new FileAppender(new PatternLayout("%-5p %d - %m%n"), AndroMDALogger
                .getNamespaceLogFileName(pluginName), true);
        logger.addAppender(appender);
    }

    /**
     * Shutdown the associated logger.
     */
    private void shutdownLogger()
    {
        Enumeration appenders = logger.getAllAppenders();
        while (appenders.hasMoreElements())
        {
            Appender appender = (Appender) appenders.nextElement();
            if (appender.getName() != null)
            {
                appender.close();
            }
        }
    }
}