/*
 *   Copyright 2005 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.felix.mishell;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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 javax.script.Bindings;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import javax.script.ScriptEngineManager;
import javax.script.SimpleBindings;

import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

/**
 * This class acts as a delegate for all the available ScriptEngineManagers. Unluckily, the standard did not
 * define it as an interface, so we need to extend it to allow polymorphism. However, no calls to super are used.
 * It wraps all available ScriptEngineManagers in the OSGi ServicePlatform into a merged ScriptEngineManager.
 * 
 * Internally, what this class does is creating ScriptEngineManagers for each bundle 
 * that contains a ScriptEngineFactory and includes a META-INF/services/javax.script.ScriptEngineFactory file. 
 * It assumes that the file contains a list of @link ScriptEngineFactory classes. For each bundle, it creates a
 * ScriptEngineManager, then merges them. @link ScriptEngineFactory objects are wrapped
 * into @link OSGiScriptEngineFactory objects to deal with problems of context class loader:
 * Those scripting engines that rely on the ContextClassloader for finding resources need to use this wrapper
 * and the @link OSGiScriptFactory. Mainly, jruby does.
 * 
 * Note that even if no context classloader issues arose, it would still be needed to search manually for the 
 * factories and either use them directly (losing the mimeType/extension/shortName mechanisms for finding engines
 * or manually registering them) or still use this class, which would be smarter. In the latter case, 
 * it would only be needed to remove the hack that temporarily sets the context classloader to the appropriate, 
 * bundle-related, class loader.
 * 
 * Caveats:
 * <ul><li>
 * All factories are wrapped with an {@link OSGiScriptEngineFactory}. As Engines are not wrapped,
 * calls like 
 * <code>
 * ScriptEngineManager osgiManager=new OSGiScriptEngineManager(context);<br>
 * ScriptEngine engine=osgiManager.getEngineByName("ruby");
 * ScriptEngineFactory factory=engine.getFactory() //this does not return the OSGiFactory wrapper
 * factory.getScriptEngine(); //this might fail, as it does not use OSGiScriptEngineFactory wrapper
 * </code>
 * might result in unexpected errors. Future versions may wrap the ScriptEngine with a OSGiScriptEngine to solve this
 * issue, but for the moment it is not needed.
 * </li>
 * 
 */
public class OSGiScriptEngineManager extends ScriptEngineManager{
	private Bindings bindings;
	private Map <ScriptEngineManager, ClassLoader> classLoaders;
	private BundleContext context;
	
	public OSGiScriptEngineManager(BundleContext context){
		this.context=context;
		bindings=new SimpleBindings();
		this.classLoaders=findManagers(context);
	}
	/**
	 * This method is the only one that is visible and not part of the ScriptEngineManager class.
	 * Its purpose is to find new managers that weren't available before, but keeping the globalScope bindings
	 * set.
	 * If you want to clean the bindings you can either get a fresh instance of OSGiScriptManager or
	 * setting up a new bindings object.
	 * This can be done with:
	 * <code>
	 * ScriptEngineManager manager=new OSGiScriptEngineManager(context);
	 * (...)//do stuff
	 * osgiManager=(OSGiScriptEngineManager)manager;//cast to ease reading
	 * osgiManager.reloadManagers();
	 * 
	 * manager.setBindings(new OSGiBindings());//or you can use your own bindings implementation
	 * 
	 * </code>   
	 *
	 */
	public void reloadManagers(){
		this.classLoaders=findManagers(context);
	}
	
	public Object get(String key) {
		return bindings.get(key);
	}

	public Bindings getBindings() {
		return bindings;
	}

	public ScriptEngine getEngineByExtension(String extension) {
		//TODO this is a hack to deal with context class loader issues
		ScriptEngine engine=null;
		for(ScriptEngineManager manager: classLoaders.keySet()){
			ClassLoader old=Thread.currentThread().getContextClassLoader();
			Thread.currentThread().setContextClassLoader(classLoaders.get(manager));
			engine=manager.getEngineByExtension(extension);
			Thread.currentThread().setContextClassLoader(old);
			if (engine!=null) break;
		}
 		return engine;
	}

	public ScriptEngine getEngineByMimeType(String mimeType) {
		//TODO this is a hack to deal with context class loader issues
		ScriptEngine engine=null;
		for(ScriptEngineManager manager: classLoaders.keySet()){
			ClassLoader old=Thread.currentThread().getContextClassLoader();
			Thread.currentThread().setContextClassLoader(classLoaders.get(manager));
			engine=manager.getEngineByMimeType(mimeType);
			Thread.currentThread().setContextClassLoader(old);
			if (engine!=null) break;
		}
 		return engine;
	}

	public ScriptEngine getEngineByName(String shortName) {
		//TODO this is a hack to deal with context class loader issues
		for(ScriptEngineManager manager: classLoaders.keySet()){
			ClassLoader old=Thread.currentThread().getContextClassLoader();
			Thread.currentThread().setContextClassLoader(classLoaders.get(manager));
			ScriptEngine engine=manager.getEngineByName(shortName);
			Thread.currentThread().setContextClassLoader(old);
			if (engine!=null){
				return new OSGiScriptEngine(engine, new OSGiScriptEngineFactory(engine.getFactory(), classLoaders.get(manager)));
			}
		}
		return null;
	}
	public List<ScriptEngineFactory> getEngineFactories() {
		List<ScriptEngineFactory> osgiFactories=new ArrayList<ScriptEngineFactory>();
		for(ScriptEngineManager engineManager: classLoaders.keySet()){
			for (ScriptEngineFactory factory : engineManager.getEngineFactories()){
				osgiFactories.add(new OSGiScriptEngineFactory(factory, classLoaders.get(engineManager)));
		}
		}
		return osgiFactories;
	}

	public void put(String key, Object value) {
		bindings.put(key, value);
	}

	public void registerEngineExtension(String extension, ScriptEngineFactory factory) {
		for(ScriptEngineManager engineManager: classLoaders.keySet())
			engineManager.registerEngineExtension(extension, factory);
	}

	public void registerEngineMimeType(String type, ScriptEngineFactory factory) {
		for(ScriptEngineManager engineManager: classLoaders.keySet())
		engineManager.registerEngineMimeType(type, factory);
	}

	public void registerEngineName(String name, ScriptEngineFactory factory) {
		for(ScriptEngineManager engineManager: classLoaders.keySet())
			engineManager.registerEngineName(name, factory);
	}
	/**
	 * Follows the same behavior of @link javax.script.ScriptEngineManager#setBindings(Bindings)
	 * This means that the same bindings are applied to all the underlying managers.
	 * @param bindings
	 */
	public void setBindings(Bindings bindings) {
		this.bindings=bindings;
		for(ScriptEngineManager manager: classLoaders.keySet()){
			manager.setBindings(bindings);
		}

	}


	private Map<ScriptEngineManager, ClassLoader> findManagers(BundleContext context) {
		Map<ScriptEngineManager, ClassLoader> managers=new HashMap<ScriptEngineManager, ClassLoader>();
		try {
			for(String factoryName: findFactoryCandidates(context)){
				//We do not really need the class, but we need the classloader 
				ClassLoader factoryLoader=Class.forName(factoryName).getClassLoader();
				ScriptEngineManager manager=new ScriptEngineManager(factoryLoader);
				manager.setBindings(bindings);
				managers.put(manager, factoryLoader);
			}
			return managers;
		} catch (IOException ioe) {
			throw new RuntimeException(ioe);
		} catch (ClassNotFoundException cnfe) {
			throw new RuntimeException(cnfe);
		}
	}
	/**
	 * Iterates through all bundles to get the available @link ScriptEngineFactory classes
	 * @return the names of the available ScriptEngineFactory classes
	 * @throws IOException
	 */
	private List<String> findFactoryCandidates(BundleContext context) throws IOException{
		Bundle[] bundles = context.getBundles();
		List<String> factoryCandidates = new ArrayList<String>();
		for (Bundle bundle : bundles) {
			System.out.println(bundle.getSymbolicName());
			if(bundle.getSymbolicName().equals("system.bundle")) continue;
			Enumeration urls = bundle.findEntries("META-INF/services",
					"javax.script.ScriptEngineFactory", false);
			if (urls == null)
				continue;
			while (urls.hasMoreElements()) {
				URL u = (URL) urls.nextElement();
				BufferedReader reader = new BufferedReader(
						new InputStreamReader(u.openStream()));
				String line;
				while ((line = reader.readLine()) != null) {
					factoryCandidates.add(line.trim());
		}
			}
		}
		return factoryCandidates;
	}
}