package org.apache.fulcrum.factory;
   
   /*
    * 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.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.concurrent.ConcurrentHashMap;
  
  import org.apache.avalon.framework.activity.Disposable;
  import org.apache.avalon.framework.activity.Initializable;
  import org.apache.avalon.framework.configuration.Configurable;
  import org.apache.avalon.framework.configuration.Configuration;
  import org.apache.avalon.framework.configuration.ConfigurationException;
  import org.apache.avalon.framework.logger.AbstractLogEnabled;
  import org.apache.fulcrum.factory.utils.ObjectInputStreamForContext;
  
  /**
   * The Factory Service instantiates objects using specified class loaders. If
   * none is specified, the default one will be used.
   * 
   * avalon.component name="factory" lifestyle="singleton" avalon.service
   * type="org.apache.fulcrum.factory.FactoryService"
   *
   * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
   * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
   * @author <a href="mailto:mcconnell@apache.org">Stephen McConnell</a>
   * @version $Id$
   *
   */
  public class DefaultFactoryService extends AbstractLogEnabled
  		implements FactoryService, Configurable, Initializable, Disposable {
  
  	/**
  	 * The property specifying a set of additional class loaders.
  	 */
  	private static final String CLASS_LOADER = "classloader";
  
  	/**
  	 * The property prefix specifying additional object factories.
  	 */
  	private static final String OBJECT_FACTORY = "object-factory";
  
  	/**
  	 * The name of the default factory.
  	 */
  	protected static final String DEFAULT_FACTORY = "default";
  
  	/**
  	 * Primitive classes for reflection of constructors.
  	 */
  	private static HashMap<String, Class<?>> primitiveClasses = new HashMap<String, Class<?>>(8);
  
  	{
  		primitiveClasses.put(Boolean.TYPE.toString(), Boolean.TYPE);
  		primitiveClasses.put(Character.TYPE.toString(), Character.TYPE);
  		primitiveClasses.put(Byte.TYPE.toString(), Byte.TYPE);
  		primitiveClasses.put(Short.TYPE.toString(), Short.TYPE);
  		primitiveClasses.put(Integer.TYPE.toString(), Integer.TYPE);
  		primitiveClasses.put(Long.TYPE.toString(), Long.TYPE);
  		primitiveClasses.put(Float.TYPE.toString(), Float.TYPE);
  		primitiveClasses.put(Double.TYPE.toString(), Double.TYPE);
  	}
  
  	/**
  	 * temporary storage of class names between configure and initialize
  	 */
  	private String[] loaderNames;
  	/**
  	 * Additional class loaders.
  	 */
  	private ArrayList<ClassLoader> classLoaders = new ArrayList<ClassLoader>();
  	/**
  	 * Customized object factories.
  	 */
  	private ConcurrentHashMap<String, Factory<?>> objectFactories = new ConcurrentHashMap<String, Factory<?>>();
  	/**
  	 * Customized object factory classes.
  	 */
 	private ConcurrentHashMap<String, String> objectFactoryClasses = new ConcurrentHashMap<String, String>();
 
 	/**
 	 * Gets the class of a primitive type.
 	 *
 	 * @param type a primitive type.
 	 * @return the corresponding class, or null.
 	 */
 	protected static Class<?> getPrimitiveClass(String type) 
 	{
 		return primitiveClasses.get(type);
 	}
 
 	/**
 	 * Gets an instance of a named class.
 	 *
 	 * @param className the name of the class.
 	 * @return the instance.
 	 * @throws FactoryException if instantiation fails.
 	 */
 	@Override
 	public <T> T getInstance(String className) throws FactoryException 
 	{
 		if (className == null) {
 			throw new FactoryException("Missing String className");
 		}
 		Factory<T> factory = getFactory(className);
 		if (factory == null) {
 			Class<T> clazz;
 			try {
 				clazz = loadClass(className);
 			} catch (ClassNotFoundException x) {
 				throw new FactoryException("Instantiation failed for class " + className, x);
 			}
 			return getInstance(clazz);
 		} else {
 			return factory.getInstance();
 		}
 	}
 
 	/**
 	 * Gets an instance of a named class using a specified class loader.
 	 *
 	 * <p>
 	 * Class loaders are supported only if the isLoaderSupported method returns
 	 * true. Otherwise the loader parameter is ignored.
 	 *
 	 * @param className the name of the class.
 	 * @param loader    the class loader.
 	 * @return the instance.
 	 * @throws FactoryException if instantiation fails.
 	 */
 	@Override
 	public <T> T getInstance(String className, ClassLoader loader) throws FactoryException 
 	{
 		Factory<T> factory = getFactory(className);
 		if (factory == null) {
 			if (loader != null) {
 				Class<T> clazz;
 				try {
 					clazz = loadClass(className, loader);
 				} catch (ClassNotFoundException x) {
 					throw new FactoryException("Instantiation failed for class " + className, x);
 				}
 				return getInstance(clazz);
 			} else {
 				return getInstance(className);
 			}
 		} else {
 			return factory.getInstance(loader);
 		}
 	}
 
 	/**
 	 * Gets an instance of a named class. Parameters for its constructor are given
 	 * as an array of objects, primitive types must be wrapped with a corresponding
 	 * class.
 	 *
 	 * @param className the name of the class.
 	 * @param params    an array containing the parameters of the constructor.
 	 * @param signature an array containing the signature of the constructor.
 	 * @return the instance.
 	 * @throws FactoryException if instantiation fails.
 	 */
 	@Override
 	public <T> T getInstance(String className, Object[] params, String[] signature) throws FactoryException 
 	{
 		Factory<T> factory = getFactory(className);
 		if (factory == null) {
 			Class<T> clazz;
 			try {
 				clazz = loadClass(className);
 			} catch (ClassNotFoundException x) {
 				throw new FactoryException("Instantiation failed for class " + className, x);
 			}
 			return getInstance(clazz, params, signature);
 		} else {
 			return factory.getInstance(params, signature);
 		}
 	}
 
 	/**
 	 * Gets an instance of a named class using a specified class loader. Parameters
 	 * for its constructor are given as an array of objects, primitive types must be
 	 * wrapped with a corresponding class.
 	 *
 	 * <p>
 	 * Class loaders are supported only if the isLoaderSupported method returns
 	 * true. Otherwise the loader parameter is ignored.
 	 * </p>
 	 *
 	 * @param           <T> Type of the class
 	 * @param className the name of the class.
 	 * @param loader    the class loader.
 	 * @param params    an array containing the parameters of the constructor.
 	 * @param signature an array containing the signature of the constructor.
 	 * @return the instance.
 	 * @throws FactoryException if instantiation fails.
 	 */
 	@Override
 	public <T> T getInstance(String className, ClassLoader loader, Object[] params, String[] signature)
 			throws FactoryException 
 	{
 		Factory<T> factory = getFactory(className);
 		if (factory == null) {
 			if (loader != null) {
 				Class<T> clazz;
 				try {
 					clazz = loadClass(className, loader);
 				} catch (ClassNotFoundException x) {
 					throw new FactoryException("Instantiation failed for class " + className, x);
 				}
 				return getInstance(clazz, params, signature);
 			} else {
 				return getInstance(className, params, signature);
 			}
 		} else {
 			return factory.getInstance(loader, params, signature);
 		}
 	}
 
 	/**
 	 * Tests if specified class loaders are supported for a named class.
 	 *
 	 * @param className the name of the class.
 	 * @return true if class loaders are supported, false otherwise.
 	 * @throws FactoryException if test fails.
 	 */
 	@Override
 	public boolean isLoaderSupported(String className) throws FactoryException 
 	{
 		Factory<?> factory = getFactory(className);
 		return factory != null ? factory.isLoaderSupported() : true;
 	}
 
 	/**
 	 * Gets an instance of a specified class.
 	 *
 	 * @param           <T> Type of the class
 	 * @param clazz the class.
 	 * @return the instance.
 	 * @throws FactoryException if instantiation fails.
 	 */
 	@Override
 	public <T> T getInstance(Class<T> clazz) throws FactoryException 
 	{
 		try {
 			return clazz.newInstance();
 		} catch (Exception x) {
 			throw new FactoryException("Instantiation failed for " + clazz.getName(), x);
 		}
 	}
 
 	/**
 	 * Gets an instance of a specified class. Parameters for its constructor are
 	 * given as an array of objects, primitive types must be wrapped with a
 	 * corresponding class.
 	 *
 	 * @param           <T> Type of the class
 	 * @param clazz     the class
 	 * @param params    an array containing the parameters of the constructor
 	 * @param signature an array containing the signature of the constructor
 	 * @return the instance
 	 * @throws FactoryException if instantiation fails.
 	 */
 	protected <T> T getInstance(Class<T> clazz, Object params[], String signature[]) 
 			throws FactoryException 
 	{
 		/* Try to construct. */
 		try {
 			Class<?>[] sign = getSignature(clazz, params, signature);
 			return clazz.getConstructor(sign).newInstance(params);
 		} catch (Exception x) {
 			throw new FactoryException("Instantiation failed for " + clazz.getName(), x);
 		}
 	}
 
 	/**
 	 * Gets the signature classes for parameters of a method of a class.
 	 *
 	 * @param clazz     the class.
 	 * @param params    an array containing the parameters of the method.
 	 * @param signature an array containing the signature of the method.
 	 * @return an array of signature classes. Note that in some cases objects in the
 	 *         parameter array can be switched to the context of a different class
 	 *         loader.
 	 * @throws ClassNotFoundException if any of the classes is not found.
 	 */
 	@Override
 	public Class<?>[] getSignature(Class<?> clazz, Object params[], String signature[]) 
 			throws ClassNotFoundException 
 	{
 		if (signature != null) {
 			/* We have parameters. */
 			ClassLoader tempLoader;
 			ClassLoader loader = clazz.getClassLoader();
 			Class<?>[] sign = new Class[signature.length];
 			for (int i = 0; i < signature.length; i++) {
 				/* Check primitive types. */
 				sign[i] = getPrimitiveClass(signature[i]);
 				if (sign[i] == null) {
 					/* Not a primitive one, continue building. */
 					if (loader != null) {
 						/* Use the class loader of the target object. */
 						sign[i] = loader.loadClass(signature[i]);
 						tempLoader = sign[i].getClassLoader();
 						if (params[i] != null && tempLoader != null
 								&& !tempLoader.equals(params[i].getClass().getClassLoader())) {
 							/*
 							 * The class uses a different class loader, switch the parameter.
 							 */
 							params[i] = switchObjectContext(params[i], loader);
 						}
 					} else {
 						/* Use the default class loader. */
 						sign[i] = loadClass(signature[i]);
 					}
 				}
 			}
 			return sign;
 		} else {
 			return null;
 		}
 	}
 
 	/**
 	 * Switches an object into the context of a different class loader.
 	 *
 	 * @param object an object to switch.
 	 * @param loader the ClassLoader to use
 	 * @param loader the loader of the new context.
 	 * @return the object
 	 */
 	protected Object switchObjectContext(Object object, ClassLoader loader) 
 	{
 		ByteArrayOutputStream bout = new ByteArrayOutputStream();
 
 		try 
 		{
 			ObjectOutputStream out = new ObjectOutputStream(bout);
 			out.writeObject(object);
 			out.flush();
 		} 
 		catch (IOException x) 
 		{
 			return object;
 		}
 
 		ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
 		ObjectInputStreamForContext in = null;
 
 		try 
 		{
 			in = new ObjectInputStreamForContext(bin, loader);
 			return in.readObject();
 		} 
 		catch (Exception x) 
 		{
 			return object;
 		} 
 		finally 
 		{
 			if (in != null) 
 			{
 				try 
 				{
 					in.close();
 				} 
 				catch (IOException e) 
 				{
 					// close quietly
 				}
 			}
 		}
 	}
 
 	/**
 	 * Loads the named class using the default class loader.
 	 *
 	 * @param className the name of the class to load.
 	 * @return {@inheritDoc} the loaded class.
 	 * @throws ClassNotFoundException if the class was not found.
 	 */
 	@SuppressWarnings("unchecked")
 	protected <T> Class<T> loadClass(String className) throws ClassNotFoundException 
 	{
 		ClassLoader loader = this.getClass().getClassLoader();
 		try 
 		{
 			Class<T> clazz;
 
 			if (loader != null) 
 			{
 				clazz = (Class<T>) loader.loadClass(className);
 			} 
 			else 
 			{
 				clazz = (Class<T>) Class.forName(className);
 			}
 
 			return clazz;
 		} 
 		catch (ClassNotFoundException x) 
 		{
 			/* Go through additional loaders. */
 			for (ClassLoader l : classLoaders) 
 			{
 				try 
 				{
 					return (Class<T>) l.loadClass(className);
 				} 
 				catch (ClassNotFoundException xx) 
 				{
 					// continue
 				}
 			}
 			/* Give up. */
 			throw x;
 		}
 	}
 
 	/**
 	 * Loads the named class using a specified class loader.
 	 *
 	 * @param className the name of the class to load.
 	 * @param loader    the loader to use.
 	 * @return {@inheritDoc} the loaded class.
 	 * @throws ClassNotFoundException if the class was not found.
 	 */
 	@SuppressWarnings("unchecked")
 	protected <T> Class<T> loadClass(String className, ClassLoader loader) throws ClassNotFoundException 
 	{
 		if (loader != null) 
 		{
 			return (Class<T>) loader.loadClass(className);
 		} 
 		else 
 		{
 			return loadClass(className);
 		}
 	}
 
 	/**
 	 * Gets a customized factory for a named class. If no class-specific factory is
 	 * specified but a default factory is, will use the default factory.
 	 *
 	 * @param className the name of the class to load.
 	 * @return {@inheritDoc} the factory, or null if not specified and no default.
 	 * @throws FactoryException if instantiation of the factory fails.
 	 */
 	@SuppressWarnings("unchecked")
 	protected <T> Factory<T> getFactory(String className) throws FactoryException 
 	{
 		Factory<T> factory = (Factory<T>) objectFactories.get(className);
 		if (factory == null) 
 		{
 			// No named factory for this; try the default, if one exists
 			factory = (Factory<T>) objectFactories.get(DEFAULT_FACTORY);
 		}
 		
 		if (factory == null) {
 			
 			/* Not yet instantiated... */
 			String factoryClass = objectFactoryClasses.get(className);
 			if (factoryClass == null) 
 			{
 				factoryClass = objectFactoryClasses.get(DEFAULT_FACTORY);
 			}
 			
 			if (factoryClass == null) {
 				return null;
 			}
 
 			try {
 				factory = getInstance(factoryClass);
 				factory.init(className);
 			} 
 			catch (ClassCastException x) 
 			{
 				throw new FactoryException("Incorrect factory " + factoryClass + " for class " + className, x);
 			}
 			
 			Factory<T> _factory = (Factory<T>) objectFactories.putIfAbsent(className, factory);
 			if (_factory != null) 
 			{
 				// Already created - take first instance
 				factory = _factory;
 			}
 		}
 
 		return factory;
 	}
 
 	// ---------------- Avalon Lifecycle Methods ---------------------
 
 	/* (non-Javadoc)
 	 * Avalon component lifecycle method
 	 * @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration)
 	 */
 	@Override
 	public void configure(Configuration conf) throws ConfigurationException 
 	{
 		final Configuration[] loaders = conf.getChildren(CLASS_LOADER);
 		if (loaders != null) 
 		{
 			loaderNames = new String[loaders.length];
 			for (int i = 0; i < loaders.length; i++) 
 			{
 				loaderNames[i] = loaders[i].getValue();
 			}
 		}
 
 		final Configuration factories = conf.getChild(OBJECT_FACTORY, false);
 		if (factories != null) 
 		{
 			// Store the factory to the table as a string and
 			// instantiate it by using the service when needed.
 			Configuration[] nameVal = factories.getChildren();
 			for (Configuration entry : nameVal)
 				objectFactoryClasses.put(entry.getName(), entry.getValue());
 
 		}
 	}
 
 	/**
 	 * Avalon component lifecycle method Initializes the service by loading default
 	 * class loaders and customized object factories.
 	 *
 	 * @throws Exception if initialization fails.
 	 */
 	@Override
 	public void initialize() throws Exception 
 	{
 		if (loaderNames != null) 
 		{
 			for (String className : loaderNames) 
 			{
 				try 
 				{
 					ClassLoader loader = (ClassLoader) loadClass(className).newInstance();
 					classLoaders.add(loader);
 				} 
 				catch (Exception x) 
 				{
 					throw new Exception("No such class loader '" + className + "' for DefaultFactoryService", x);
 				}
 			}
 			loaderNames = null;
 		}
 	}
 
 	/**
 	 * Avalon component lifecycle method Clear lists and maps
 	 */
 	@Override
 	public void dispose() 
 	{
 		objectFactories.clear();
 		objectFactoryClasses.clear();
 		classLoaders.clear();
 	}
 }