package de.keepondreaming.xml;
   
   import java.lang.reflect.Method;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Map;
   import java.util.Properties;
   import java.util.Set;
   
  import de.keepondreaming.xml.util.Util;
  
  /***
   * Resolves interfaces and attributes via a {@link java.util.Properties} mapping.
   * <p>
   * If the mapping does not resolve the strategy can be configured via the constructor
   * {@link #ClassNameMappingObjectStrategy(Properties, boolean)} to use a backup
   * strategy, usually {@link de.keepondreaming.xml.ProxyObjectStrategy}
   * <p>
   * Property mappings are as follows:
   * <ul>
   * <li>Interface to class mapping: &lt;Interface-name&gt;=&lt;Class-name&gt;, <p>i.e. <code>de.keepondreaming.xml.example.Root=de.keepondreaming.xml.example.impl.RootImpl</code></li>
   * <li>Map XML-tagname to getter method:&lt;interface-name&gt;.&lt;tag-name&gt;=&lt;getter-method&gt;, <p>i.e. <code>de.package.MyClass.UGLY_XML_TAG_NAME=getNiceNamedMethod</code></li>
   * <li>Map XML-tagname to setter method:<b>&lt;class-name&gt;</b>.&lt;tag-name&gt;=&lt;setter-method&gt;, <p>i.e. <code>de.package.MyClassImpl.UGLY_XML_TAG_NAME=setNiceNamedMethodWithOtherName</code></li>
   * </ul> 
   * Note that the mappings of XML tagnames to setter/getter methods is only needed if the methods can not get obtained via reflection
   * 
   * <p>
   * $Author: wintermond $
   * $Date: 2005/07/10 18:38:43 $
   * $Log: ClassNameMappingObjectStrategy.java,v $
   * Revision 1.1  2005/07/10 18:38:43  wintermond
   * Renamed ImplObjectStrategy to ClassNameMappingStrategy
   * Performance improvements
   *
   * Revision 1.2  2005/07/09 09:56:38  wintermond
   * Javadoc and implemented ProxyClassCreator. Backupstrategy now more generic
   *
   */
  public class ClassNameMappingObjectStrategy implements ObjectStrategy
  {
  	/***
  	 * Backup strategy if mapping information is insufficient.
  	 */
  	private ObjectStrategy backupStrategyM = null;
  	
  	/***
  	 * lookup cache, stores mappings of interfaces to classes
  	 */
  	private Map<Class, Class> classCacheM = new HashMap<Class, Class>();
  	
  	/***
  	 * reverse cache, caches the implementation classes to the interfaces
  	 */
  	private Map<Class, Class> interfaceCacheM = new HashMap<Class, Class>();
  	
  	/***
  	 *	Stores all classes already instanciated by this instance 
  	 */
  	private Set<Class> cachedClassesM = new HashSet<Class>();
  	
  	/***
  	 *	To prevent spamming of messages unresolved attributes get logged here 
  	 */
  	private Set<String> unresolvedAttributes = new HashSet<String>();
  	
  	/***
  	 * Mapping information, tells the strategy how to map
  	 * interfaces to classes and the name of setter methods.
  	 */
  	private Properties mappingsM = null;
  	
  	/***
  	 *	Performance optimisation: method lookup for {@link #setAttribute(Object, String, Object))} 
  	 */
  	private Map<String, Method> methodCacheM = new HashMap<String, Method>();
  	
  	/***
  	 * Default constructor
  	 * 
  	 * @param mappings Must not be null;
  	 */
  	public ClassNameMappingObjectStrategy(Properties mappings)
  	{
  		this(mappings, true);
  	}
  
  	/***
  	 * Constructor, specifying if in case of insufficient mapping information
  	 * the call should get passed to the backup strategy
  	 * 
  	 * @param mappings
  	 * @param useProxyMapping
  	 */
  	public ClassNameMappingObjectStrategy(Properties mappings, boolean useProxyMapping)
  	{
  		if(useProxyMapping)
  		{
  			backupStrategyM = new ProxyObjectStrategy();
  		}
 		if(mappings == null)
 		{
 			throw new NullPointerException("maping is null");
 		}
 		mappingsM = mappings;
 	}
 
 	/* (non-Javadoc)
 	 * @see de.keepondreaming.xml.ObjectStrategy#createInstance(java.lang.Class)
 	 */
 	public Object createInstance(Class clazz)
 	{
 		Object result = null;
 		
 		//
 		//	Lookup parameter in class cache
 		//
 		Class creatorClass = classCacheM.get(clazz); 
 		
 		//
 		//	Not cached, so try to resolve the class
 		//
 		if(creatorClass == null)
 		{
 			String className = mappingsM.getProperty(clazz.getName());
 			if(className != null)
 			{
 				try
 				{
 					creatorClass = Class.forName(className);
 					classCacheM.put(clazz, creatorClass);		
 					cachedClassesM.add(creatorClass);
 					interfaceCacheM.put(creatorClass, clazz);
 				}
 				catch (ClassNotFoundException e)
 				{
 					throw new IllegalArgumentException("Unkown class [" + className + "] specified in mapping!");
 				}							
 			}
 			//
 			//	Information not stored in mapping, see if a backupStrategy should be used 
 			//
 			else if(backupStrategyM == null)
 			{
 				throw new IllegalArgumentException("No mapping specified for class [" + className + "]!");
 			}
 			else
 			{
 				result = backupStrategyM.createInstance(clazz);				
 			}
 		}
 		
 		//
 		//	Class information could be obtained, no backup strategy was used
 		//
 		if(result == null)
 		{
 			try
 			{
 				result = creatorClass.newInstance();
 			}
 			catch (Throwable e)
 			{
 				throw new IllegalArgumentException("Error while instanciating class [" + creatorClass.getName() + "]", e);
 			}			
 		}
 		
 		return result;
 	}
 
 	/* (non-Javadoc)
 	 * @see de.keepondreaming.xml.ObjectStrategy#setAttribute(java.lang.Object, java.lang.String, java.lang.Object)
 	 */
 	/* (non-Javadoc)
 	 * @see de.keepondreaming.xml.ObjectStrategy#setAttribute(java.lang.Object, java.lang.String, java.lang.Object)
 	 */
 	public void setAttribute(Object target, String attribute, Object value)
 	{
 		Method method = getMethod(target, attribute, value);
 		
 		if(method != null)
 		{
 			try
 			{
 				method.invoke(target, new Object[]{value});	
 			}
 			catch (Throwable e)
 			{
 				throw new IllegalArgumentException("Could not set value [" + value + "] of attribute [" + attribute + "] in object [" + target + "] using method [" + method + "]. Value class is [" + value.getClass() + "]", e);		
 			}
 		}
 		else if(backupStrategyM != null && !cachedClassesM.contains(target.getClass()))
 		{
 			backupStrategyM.setAttribute(target, attribute, value);
 		}
 		else
 		{
 			String key = target.getClass().getName() 
 							+ "."
 							+ attribute;
 
 			if(!unresolvedAttributes.contains(key))
 			{
 				unresolvedAttributes.add(key);
 				System.err.println("Could not resolve setter for attribute " + attribute + " of class " + target.getClass());	
 			}							
 		}			
 
 	}
 
 	private Method getMethod(Object target, String attribute, Object value)
 	{
 		//
 		//	Try to lookup setter method via standard naming patterns and 
 		//	mapping entries
 		//
 		String key = target.getClass().getName() 
 						+ "."
 						+ attribute;
 		
 		Method result = methodCacheM.get(key);
 		
 		if(result == null)
 		{
 			String backupKey = "set"
 								+ Util.capitalize(attribute);
 			String methodName = mappingsM.getProperty(key, backupKey);
 			
 			try
 			{
 				Class valueClass = value.getClass();
 				
 				//  if the object was created by a backup strategy and is a dynamic proxy
 				//	the method lookup needs to obtain the original class
 				if (value instanceof ProxyClassCreator)
 				{
 					valueClass = ((ProxyClassCreator) value).getWrappedClass(value);				
 				}
 				result = target.getClass().getMethod(methodName, new Class[]{valueClass});			
 			}
 			catch (NoSuchMethodException checkForPrimitive)
 			{
 				//
 				//	Maybe its not 
 				//		public void setFoo(Integer a) 
 				//	but 
 				//		public void setFoo(int a)
 				//
 				Class primitive = Util.computePrimitiveClass(value);
 				if(primitive != null)
 				{
 					try
 					{
 						result = target.getClass().getMethod(methodName, new Class[]{primitive});			
 					}
 					catch (NoSuchMethodException ignore)
 					{
 						// left blank
 					}		
 				}
 			}
 			
 			if(result != null)
 			{
 				methodCacheM.put(key, result);
 			}
 		}
 		return result;
 	}
 
 	/* (non-Javadoc)
 	 * @see de.keepondreaming.xml.ObjectStrategy#init()
 	 */
 	public void init()
 	{
 		classCacheM.clear();
 		cachedClassesM.clear();
 		interfaceCacheM.clear();
 		unresolvedAttributes.clear();
 		methodCacheM.clear();
 	}
 
 	/* (non-Javadoc)
 	 * @see de.keepondreaming.xml.ObjectStrategy#resolveInterface(java.lang.Object)
 	 */
 	public Class resolveInterface(Object object)
 	{
 		Class result = interfaceCacheM.get(object.getClass());
 		if(result == null)
 		{
 			result = backupStrategyM.resolveInterface(object);
 		}
 		return result;
 	}
 
 	/* (non-Javadoc)
 	 * @see de.keepondreaming.xml.ObjectStrategy#getMethodName(java.lang.Class, java.lang.String, boolean)
 	 */
 	public String getMethodName(Class clazz, String attribute, boolean set)
 	{
 		String key = clazz.getName() + "." + attribute;
 		String result = mappingsM.getProperty(key);
 		return result;
 	}
 	
 	
 
 
 }