/*
 * (c) Copyright 2010-2011 AgileBirds
 *
 * This file is part of OpenFlexo.
 *
 * OpenFlexo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * OpenFlexo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OpenFlexo. If not, see <http://www.gnu.org/licenses/>.
 *
 */
package org.openflexo.velocity;

import java.io.FileInputStream;
import java.io.StringWriter;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.apache.commons.collections.ExtendedProperties;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.exception.ParseErrorException;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.apache.velocity.runtime.RuntimeConstants;
import org.apache.velocity.runtime.RuntimeSingleton;
import org.apache.velocity.util.introspection.Uberspect;
import org.openflexo.foundation.cg.templates.CGTemplate;
import org.openflexo.generator.TemplateLocator;
import org.openflexo.logging.FlexoLogger;
import org.openflexo.toolbox.FileResource;

import com.google.inject.Injector;

/**
 * @author gpolet
 * 
 */
public class FlexoVelocity {
	protected static final Logger logger = FlexoLogger.getLogger(FlexoVelocity.class.getPackage().getName());
	private static boolean isInitialized = false;

	private static FlexoVelocityResourceCache resourceCache;

	private static Injector injector;

	static {
		try {
			init();
		} catch (Exception e) {
			e.printStackTrace();
			if (logger.isLoggable(Level.WARNING)) {
				logger.warning("Error while initializing Velocity");
			}
		}
	}

	public static Logger getLogger() {
		return logger;
	}

	public synchronized static void addToVelocimacro(TemplateLocator templateLocator, CGTemplate[] templates)
			throws ResourceNotFoundException, ParseErrorException, Exception {
		if (logger.isLoggable(Level.INFO)) {
			logger.info("Adding macros: " + templates);
		}
		if (resourceCache != null) {
			resourceCache.clearCache();
		}
		Velocity.setApplicationAttribute("templateLocator", templateLocator);
		for (CGTemplate template : templates) {
			if (template != null) {
				Velocity.getTemplate(template.getRelativePath());
			}
		}
		Velocity.setApplicationAttribute("templateLocator", null);
	}

	/**
	 * @throws Exception
	 * 
	 */
	public synchronized static void init() throws Exception {
		if (!isInitialized) {
			// 1. We load properties with the Java object because it loads property files correctly unlike ExtendedProperties (which does
			// not handle properly "\ " as value " ")
			Properties p = new Properties();
			p.load(new FileInputStream(new FileResource("Config/velocity.properties")));
			for (Entry<Object, Object> e : p.entrySet()) {
				String value = e.getValue().toString();
				if (value.indexOf("${") > -1) {
					for (Entry<Object, Object> sp : System.getProperties().entrySet()) {
						value = value.replace("${" + sp.getKey() + "}", sp.getValue().toString());
					}
					p.setProperty(e.getKey().toString(), value);
				}

			}
			// 2. We convert properties to extended properties (this conversion only handles values of type String (i.e., a VelocityLogger
			// cannot be set directly in the Properties, see 3.)
			ExtendedProperties ep = ExtendedProperties.convertProperties(p);
			VelocityLogger vl = new VelocityLogger();
			// 3. We set our logger so that it does not try to use its own
			ep.setProperty(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM, vl);
			// 4. We force our configuration to be loaded
			RuntimeSingleton.getRuntimeServices().setConfiguration(ep);
			// 5. We initialize properly Velocity passing no properties at all!
			Velocity.init();
			isInitialized = true;
			if (logger.isLoggable(Level.FINE)) {
				logger.fine("Velocity Engine started");
			}
		}
	}

	public static void setResourceCache(FlexoVelocityResourceCache resourceCache) {
		if (logger.isLoggable(Level.INFO)) {
			logger.info("Setting Velocity resource cache");
		}
		FlexoVelocity.resourceCache = resourceCache;
	}

	public static void clearResourceCache() {
		if (resourceCache != null) {
			resourceCache.clearCache();
		}
	}

	public static void mergeTemplate(String templateName, String encoding, VelocityContext context, StringWriter writer) {
		Velocity.mergeTemplate(templateName, encoding, context, writer);
	}

	public static void clearCaches() {
		clearResourceCache();
		Uberspect introspector = RuntimeSingleton.getRuntimeServices().getUberspect();
		if (introspector instanceof FlexoVelocityIntrospector) {
			((FlexoVelocityIntrospector) introspector).clearCache();
		}
	}
}