package net.sourceforge.jparam.conversion.creators;
   
   import java.util.Arrays;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
  import java.util.TreeMap;
  
  import net.sourceforge.jparam.JParamException;
  import net.sourceforge.jparam.conversion.weights.ScalarConversionWeight;
  import net.sourceforge.jparam.parser.SimpleLeaf;
  import net.sourceforge.jparam.parser.TreeNode;
  import net.sourceforge.jparam.util.MultiMap;
  
  public class ObjectCreator {
  	private static ObjectCreator objectCreator = null;
  
  	private Map primitiveTypeMap = new HashMap();
  
  	private ObjectCreator() {
  		primitiveTypeMap.put(Boolean.TYPE, Boolean.class);
  		primitiveTypeMap.put(Character.TYPE, Character.class);
  		primitiveTypeMap.put(Byte.TYPE, Byte.class);
  		primitiveTypeMap.put(Short.TYPE, Short.class);
  		primitiveTypeMap.put(Integer.TYPE, Integer.class);
  		primitiveTypeMap.put(Long.TYPE, Long.class);
  		primitiveTypeMap.put(Float.TYPE, Float.class);
  		primitiveTypeMap.put(Double.TYPE, Double.class);
  	}
  
  	public boolean isPrimitive(Class c) {
  		return (c.isPrimitive() || primitiveTypeMap.containsKey(c));
  	}
  
  	public Class getNonPrimitiveClass(Class c) {
  		if (c.isPrimitive()) {
  			return (Class) primitiveTypeMap.get(c);
  		}
  		return c;
  	}
  
  	public static ObjectCreator getInstance() {
  		if (objectCreator == null) {
  			objectCreator = new ObjectCreator();
  		}
  		return objectCreator;
  	}
  
  	public Object create(Class bt, TreeNode[] paramNodes)
  			throws JParamException {
  		Set availableCreators = CreatorRegistry.getInstance().getCreators(bt);
  		boolean isArgNull[] = new boolean[paramNodes.length];
  		for (int i = 0; i < paramNodes.length; i++) {
  			TreeNode node = paramNodes[i];
  
  			if (node instanceof SimpleLeaf) {
  				Object val = node.getConstructedValue(Object.class);
  				if (val == null) {
  					isArgNull[i] = true;
  				}
  			}
  		}
  
  		// have a map from the weight to all creators with this weight
  		// convertion
  		List possibleCreators = new LinkedList();
  		for (Iterator iter = availableCreators.iterator(); iter.hasNext();) {
  			ICreator creator = (ICreator) iter.next();
  			Class[] expectedParameters = creator.getParameterTypes();
  
  			if (expectedParameters.length == paramNodes.length) {
  				boolean impossible = false;
  				ScalarConversionWeight[] parametersConversionWeights = new ScalarConversionWeight[paramNodes.length];
  				for (int i = 0; i < expectedParameters.length; i++) {
  					ScalarConversionWeight cw = paramNodes[i]
  							.getConversionWeight(expectedParameters[i]);
  					if ((!creator.canBeNull(i) && isArgNull[i])
  							|| (cw
  									.compareTo(ScalarConversionWeight.CONV_IMPOSSIBLE) == 0)) {
  						impossible = true;
  						continue;
  					}
  					parametersConversionWeights[i] = cw;
  				}
  
  				if (!impossible) {
  					possibleCreators.add(new WeightedCreator(creator,
  							parametersConversionWeights));
  				}
  			}
  		}
  
  		if (possibleCreators.size() == 0) {
  			throw new JParamException("No creator available for type: "
  					+ bt.getName() + " with parameters: "
  					+ Arrays.asList(paramNodes));
 		}
 
 		ICreator[] bestCreators = findBest((WeightedCreator[]) possibleCreators
 				.toArray(new WeightedCreator[possibleCreators.size()]));
 
 		if (bestCreators.length > 1) {
 			throw new JParamException("Ambiguity creating: " + bt.getName()
 					+ " with parameters: " + Arrays.asList(paramNodes)
 					+ ", available creators: " + Arrays.asList(bestCreators));
 		}
 		ICreator creator = bestCreators[0];
 		Object[] args = new Object[paramNodes.length];
 		Class[] creatorParameters = creator.getParameterTypes();
 		for (int i = 0; i < args.length; i++) {
 			args[i] = paramNodes[i].getConstructedValue(creatorParameters[i]);
 		}
 		return creator.create(args);
 	}
 
 	private ICreator[] findBest(WeightedCreator[] creators) {
 		MultiMap weightedCreators = new MultiMap(new TreeMap());
 
 		Set bestMatches = null;
 		for (int i = 0; i < creators.length; i++) {
 			WeightedCreator curCreator = creators[i];
 
 			int creatorIsAsGoodAs = 0;
 			for (int j = 0; j < creators.length; j++) {
 				if (j == i) {
 					continue;
 				}
 
 				if (curCreator.isAsGood(creators[j])) {
 					creatorIsAsGoodAs++;
 				}
 			}
 
 			weightedCreators.put(new Integer(creatorIsAsGoodAs), curCreator);
 		}
 
 		bestMatches = weightedCreators.get(new Integer(creators.length - 1));
 		ICreator[] c;
 
 		if (bestMatches == null) {
 			c = new ICreator[creators.length];
 			for (int i = 0; i < c.length; i++) {
 				c[i] = creators[i].creator;
 			}
 		} else {
 			boolean areAllAsGood = true;
 
 			if (bestMatches.size() > 1) {
 				for (Iterator i = bestMatches.iterator(); i.hasNext()
 						&& areAllAsGood;) {
 					WeightedCreator ic = (WeightedCreator) i.next();
 					for (Iterator j = bestMatches.iterator(); j.hasNext()
 							&& areAllAsGood;) {
 						WeightedCreator jc = (WeightedCreator) j.next();
 						if (!jc.isAsGood(ic)) {
 							areAllAsGood = false;
 						}
 					}
 				}
 			}
 
 			if (!areAllAsGood) {
 				c = new ICreator[bestMatches.size()];
 				int i = 0;
 				for (Iterator iter = bestMatches.iterator(); iter.hasNext(); i++) {
 					WeightedCreator wc = (WeightedCreator) iter.next();
 					c[i] = wc.creator;
 				}
 			} else {
 				c = new ICreator[1];
 				c[0] = ((WeightedCreator) bestMatches.iterator().next()).creator;
 			}
 		}
 		return c;
 	}
 
 	public static void clearSingleton() {
 		objectCreator = null;
 	}
 
 	private class WeightedCreator {
 		ICreator creator;
 
 		ScalarConversionWeight parameterWeights[];
 
 		/***
 		 * @param creator
 		 * @param parameterWeights
 		 */
 		public WeightedCreator(ICreator creator,
 				ScalarConversionWeight[] parameterWeights) {
 			super();
 			this.creator = creator;
 			this.parameterWeights = parameterWeights;
 		}
 
 		public boolean isAsGood(WeightedCreator other) {
 			ScalarConversionWeight[] otherParameterWeights = other.parameterWeights;
 
 			int better = 0;
 			int worse = 0;
 
 			for (int i = 0; i < parameterWeights.length; i++) {
 				int comparedWeight = parameterWeights[i]
 						.compareTo(otherParameterWeights[i]);
 				if (comparedWeight > 0) {
 					worse++;
 				} else if (comparedWeight < 0) {
 					better++;
 				}
 
 				return better - worse >= 0;
 			}
 
 			return true;
 		}
 
 		public String toString() {
 			return "Weights: " + Arrays.asList(parameterWeights) + " Creator: "
 					+ creator;
 		}
 	}
 }