package net.sourceforge.jparam.conversion;
   
   import java.lang.reflect.Method;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.Map;
   
  import net.sourceforge.jparam.JParamException;
  import net.sourceforge.jparam.conversion.converters.AmbigousConverter;
  import net.sourceforge.jparam.conversion.converters.IConverter;
  import net.sourceforge.jparam.conversion.converters.MethodConverter;
  import net.sourceforge.jparam.conversion.converters.PathConverter;
  import net.sourceforge.jparam.conversion.creators.ObjectCreator;
  import net.sourceforge.jparam.conversion.weights.ScalarConversionWeight;
  import net.sourceforge.jparam.typename.TypeNameRegistry;
  
  /***
   * This registry maintains a list of all possible conversions that are currently
   * supported by JParam, if new conversions are added than the list is updated
   * accordingly
   *  
   * @author ron_sidi
   * 
   */
  public class ConverterRegistry {
  	private static ConverterRegistry registry = null;
  
  	private Map converters = new HashMap();
  
  	private ConverterRegistry() {
  	}
  
  	public static ConverterRegistry getInstance() {
  		if (registry == null) {
  			registry = new ConverterRegistry();
  		}
  		return registry;
  	}
  
  	/***
  	 * Register all conversion methods in the given helper class, a method is
  	 * considered a conversion if:
  	 * <p>
  	 * <li>The method name is:
  	 * <ul>
  	 * <li>convert/user_convert for performing user conversions</li>
  	 * <li>promote_convert for promotion conversion</li>
  	 * <li>std_convert for standard conversion</li>
  	 * </ul>
  	 * <li>The method is <code>public</code></li>
  	 * <li>The method is <code>static</code></li>
  	 * <li>The method has exactly one argument</li>
  	 * <li>The method has a typed return value and not void</li>
  	 * 
  	 * @param helperClass
  	 */
  	public void registerHelperClass(Class helperClass) {
  		Method[] creatorClassMethods = helperClass.getMethods();
  		for (int i = 0; i < creatorClassMethods.length; i++) {
  			Method m = creatorClassMethods[i];
  
  			if (MethodConverter.isMethodValid(m)) {
  				MethodConverter mc = new MethodConverter(m);
  
  				registerConverter(mc);
  			}
  		}
  	}
  
  	/***
  	 * This method is used to register a new converter, it shouldn't be used
  	 * externally, but is defined public to support special cases that might
  	 * arise
  	 * 
  	 * It will perform all needed changes to the registry that are introduced by
  	 * the new converter
  	 * 
  	 * @param c
  	 */
  	public void registerConverter(IConverter c) {
  		ConverterKey key = new ConverterKey(c.getSourceClass(), c
  				.getTargetClass());
  
  		// don't register converters from a type to itself...
  		if (key.sourceType.equals(key.targetType)) {
  			return;
  		}
  
  		// Try to find an existing converter for the given conversion
  		IConverter curConverter = (IConverter) converters.get(key);
  		if (curConverter != null) {
  			// if one exists, and is worse then the new one, update the current
  			// converter
  			if (curConverter.getWeight().compareTo(c.getWeight()) > 0) {
  				updateConverter(c);
  			} else
  			// if the converters are equal in weight, make them ambigous
 			if (curConverter.getWeight().compareTo(c.getWeight()) == 0) {
 				// there are scenarios when the same converter could be
 				// registered twice, for instance:
 				// we have a->b and c->d, now register b->c
 				// this will register a->c and b->d, when these converters are
 				// registered, they will trigger a->d using the same path...
 				if (!curConverter.equals(c)) {
 					// this means there is an ambiguity
 					updateConverter(AmbigousConverter.createConverter(
 							curConverter, c));
 				}
 			}
 			// if the new converter is worse then the current one simply
 			// ignore it
 		} else {
 			List convertersToRegister = new LinkedList();
 			boolean userConversion = c.getWeight().compareTo(
 					ScalarConversionWeight.CONV_USER) >= 0;
 			// create a converter for all possible concatenations of the new
 			// converter with existing converters
 			for (Iterator iter = converters.entrySet().iterator(); iter
 					.hasNext();) {
 				Map.Entry entry = (Map.Entry) iter.next();
 
 				IConverter existingConverter = (IConverter) entry.getValue();
 				if (!userConversion
 						|| existingConverter.getWeight().compareTo(
 								ScalarConversionWeight.CONV_USER) < 0) {
 					if (existingConverter.getSourceClass().equals(
 							c.getTargetClass())) {
 						// exis(a->b), new(c->a) -> create (c->b) {make sure
 						// a->b + b->a won't create b->b}
 						if (!existingConverter.getTargetClass().equals(
 								c.getSourceClass())) {
 							convertersToRegister
 									.add(PathConverter.createConversionPath(c,
 											existingConverter));
 						}
 					} else if (existingConverter.getTargetClass().equals(
 							c.getSourceClass())) {
 						// exis(a->b), new(b->c) -> create (a->c) {make sure
 						// a->b + b->a won't create a->a}
 						if (!existingConverter.getSourceClass().equals(
 								c.getTargetClass())) {
 							convertersToRegister
 									.add(PathConverter.createConversionPath(
 											existingConverter, c));
 						}
 					}
 				}
 			}
 
 			// there is no need to do an update here since we branch here only
 			// if there is no converter for key...
 			converters.put(key, c);
 			for (Iterator iter = convertersToRegister.iterator(); iter
 					.hasNext();) {
 				IConverter converter = (IConverter) iter.next();
 				registerConverter(converter);
 			}
 		}
 	}
 
 	private void updateConverter(IConverter converter) {
 		List updatedConverters = new LinkedList();
 		ConverterKey key = new ConverterKey(converter.getSourceClass(),
 				converter.getTargetClass());
 
 		converters.remove(key);
 		for (Iterator iter = converters.values().iterator(); iter.hasNext();) {
 			IConverter curConv = (IConverter) iter.next();
 			IConverter newConv = curConv.update(converter);
 
 			if (newConv != curConv) {
 				updatedConverters.add(newConv);
 			}
 		}
 		converters.put(key, converter);
 
 		for (Iterator iter = updatedConverters.iterator(); iter.hasNext();) {
 			IConverter conv = (IConverter) iter.next();
 			updateConverter(conv);
 		}
 	}
 
 	/***
 	 * Convert the source object to the given target class, an exception is
 	 * thrown either when there is no exception/exception is ambigous or when
 	 * the conversion process itself failed
 	 * 
 	 * @param targetType
 	 * @param sourceObject
 	 * @return the converted object
 	 * @throws JParamException
 	 */
 	public Object convert(Class targetType, Object sourceObject)
 			throws JParamException {
 		if (sourceObject == null) {
 			if (targetType.isPrimitive()) {
 				throw new JParamException(
 						"The value \"null\" cannot be converted into a primitive: "
 								+ targetType);
 			}
 			return null;
 		}
 
 		targetType = ObjectCreator.getInstance().getNonPrimitiveClass(
 				targetType);
 		if (sourceObject.getClass().equals(targetType)) {
 			return sourceObject;
 		}
 
 		IConverter converter = (IConverter) converters.get(new ConverterKey(
 				sourceObject.getClass(), targetType));
 		if (converter == null) {
 			throw new JParamException("no conversion path found from "
 					+ TypeNameRegistry.getInstance().getJParamTypeName(
 							sourceObject.getClass())
 					+ " to "
 					+ TypeNameRegistry.getInstance().getJParamTypeName(
 							targetType));
 		}
 		return converter.convert(sourceObject);
 	}
 
 	public static void clearSingleton() {
 		registry = null;
 	}
 
 	/***
 	 * Return the weight of the conversion between the given source and target
 	 * type
 	 * 
 	 * @param sourceType
 	 * @param targetType
 	 * @return
 	 */
 	public ScalarConversionWeight getConversionWeight(Class sourceType,
 			Class targetType) {
 		if (sourceType.equals(targetType)) {
 			return ScalarConversionWeight.CONV_EXACT;
 		}
 
 		IConverter converter = (IConverter) converters.get(new ConverterKey(
 				sourceType, targetType));
 		if (converter != null) {
 			return converter.getWeight();
 		}
 
 		return ScalarConversionWeight.CONV_IMPOSSIBLE;
 	}
 }