/*
    * Copyright 2005 by Mark Vollmann Hamburg, Germany. All rights reserved.
    * 
    * mail to mark.vollmann@web.de
    * 
    * Created on 05.07.2005
    */
   package de.keepondreaming.xml;
   
  import java.io.IOException;
  import java.io.InputStream;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Stack;
  
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.parsers.SAXParser;
  import javax.xml.parsers.SAXParserFactory;
  
  import org.xml.sax.Attributes;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.helpers.DefaultHandler;
  
  import de.keepondreaming.xml.util.Util;
  
  /***
   * Reads an xml file and sets the data using the passed strategy patterns
   * 
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ $Log: XmlConverter.java,v $
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ Revision 1.1  2005/07/10 18:37:00  wintermond
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ Renamed Parser to XMLConverter
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ Major performance improvements
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ Support for java.util.Date, java.sql.Date and java.sql.TimeStamp as return types
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ Support for attributes modelled as sub tags
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $ Support for method getters/setter with names different from the xml names
   * $Author: wintermond $ $Date: 2005/07/10 18:37:00 $
   * Revision 1.4 2005/07/09 14:11:54 wintermond Introduced ability to handle
   * subtags that contain simple values
   * 
   * Revision 1.3 2005/07/09 09:57:58 wintermond Javadoc, moved some methods to
   * Util class
   * 
   */
  public class XmlConverter extends DefaultHandler
  {
  	private static final Object[] NO_PARAMETERS = new Object[0];
  
  	/***
  	 * Default parser
  	 */
  	private SAXParser parserM = null;
  
  	/***
  	 * Holds the object tree
  	 */
  	private Stack<Object> stackM = new Stack<Object>();
  
  	/***
  	 * strategy used to obtain runtime information not resolvable via reflection
  	 */
  	private AnnotationStrategy annotationStrategyM = null;
  
  	/***
  	 * Strategy used to create objects and set attributes
  	 */
  	private ObjectStrategy objectStrategyM = null;
  
  	/***
  	 * Method cached to handle attributes that appear as subtag in xml
  	 */
  	private Method stackedMethodM;
  
  	/***
  	 * Element name cached to handle attributes that appear as subtag in xml
  	 */
  	private String stackedElementM;
  
  	/***
  	 * Converts read date strings into date objects
  	 */
  	private DateHandler dateHandlerM;
  
  	/***
  	 * Caches the found getter methods
  	 */
  	private Map<String, Method> methodCacheM = new HashMap<String, Method>();
  
  	/***
  	 * Caches for ever class the valid methods for which set operations apply
  	 */
  	private Map<Class, List<Method>> validMethodsCacheM = new HashMap<Class, List<Method>>(101);
  
  	/***
 	 * Default constructor
 	 * 
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 * @throws NullPointerException If any parameter is null
 	 */
 	public XmlConverter(AnnotationStrategy parserStrategy, ObjectStrategy objectStrategy) throws ParserConfigurationException, SAXException
 	{
 		if (parserStrategy == null)
 		{
 			throw new IllegalArgumentException("parserStrategy is null");
 		}
 		if (objectStrategy == null)
 		{
 			throw new IllegalArgumentException("objectStrategy is null");
 		}
 
 		SAXParserFactory factory = SAXParserFactory.newInstance();
 		parserM = factory.newSAXParser();
 		annotationStrategyM = parserStrategy;
 		objectStrategyM = objectStrategy;
 	}
 
 	/***
 	 * Reads the xml from the stream and sets the data structures accordingly
 	 * using reflection. The type of <rootElement> is expected to be the root
 	 * node in the xml structure
 	 * 
 	 * @param in
 	 * @param rootElement Must be an interface
 	 * 
 	 * @return An object containing the root data read from the 
 	 * 		inpustream. This object is assignable to the interface 
 	 * 		passed by <code>rootElement</code>
 	 * 
 	 * @throws IOException
 	 *             Error while reading the data from the stream
 	 * @throws SAXException
 	 * @throws IllegalArgumentException <code>rootElement</code> is not an interface
 	 */
 	@SuppressWarnings( { "unchecked" })
 	public Object convert(InputStream in, Class rootElement) throws IOException, SAXException
 	{
 		return parse(new InputSource(in), rootElement);
 	}
 
 	/***
 	 * Reads the xml from the stream and sets the data structures accordingly
 	 * using reflection. The type of <rootElement> is expected to be the root
 	 * node in the xml structure
 	 * 
 	 * @param in
 	 * @param rootElement
 	 * 
 	 * @return An object containing the root data read from the 
 	 * 		inpustream. This object is assignable to the interface 
 	 * 		passed by <code>rootElement</code>
 	 * 
 	 * @throws IOException
 	 *             Error while reading the data from the stream
 	 * @throws SAXException
 	 * @throws IllegalArgumentException <code>rootElement</code> is not an interface
 	 */
 	@SuppressWarnings( { "unchecked" })
 	public Object parse(InputSource in, Class rootElement) throws IOException, SAXException
 	{
 		if(!rootElement.isInterface())
 		{
 			throw new IllegalArgumentException("rootElement is not an interface");
 		}
 		Object resultM = init(rootElement);
 
 		parserM.parse(in, this);
 		return resultM;
 	}
 
 	
 	/***
 	 * Initializes the parser
 	 * 
 	 * @param rootElement
 	 * 
 	 * @return The root element of the parsed data
 	 */
 	private Object init(Class rootElement)
 	{
 		objectStrategyM.init();
 		annotationStrategyM.init();
 		methodCacheM.clear();
 		validMethodsCacheM.clear();
 		if (dateHandlerM == null)
 		{
 			dateHandlerM = new DateHandler(annotationStrategyM);
 		}
 		stackedElementM = null;
 		stackedMethodM = null;
 
 		Object result = objectStrategyM.createInstance(rootElement);
 		stackM.push(result);
 		return result;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xml.sax.ContentHandler#characters(char[], int, int)
 	 */
 	@Override
 	@SuppressWarnings( { "unchecked" })
 	public void characters(char[] chars, int start, int len) throws SAXException
 	{
 		String content = new String(chars, start, len).trim();
 
 		if (content.length() > 0)
 		{
 			//
 			// It is assumed that the object has a method with the
 			// signature getContent() if no content attribute is supplied
 			Object current = stackM.peek();
 			if (stackedElementM != null)
 			{
 				Object value = content;
 				Class returnType = stackedMethodM.getReturnType();
 				if (returnType.isPrimitive())
 				{
 					value = Util.getPrimitiveObject(returnType, content);
 				}
 				else if (!String.class.isAssignableFrom(returnType))
 				{
 					value = Util.createObject(returnType, content);
 				}
 				objectStrategyM.setAttribute(current, stackedElementM, value);
 
 				// we cannot set stackedElement and stackedMethod to null, since
 				// endElement will pop the stack. Since in this case no element
 				// got
 				// pushed, the wrong element will get popped
 			}
 			else
 			{
 				String contentAttribute = annotationStrategyM.getContentAttribute(objectStrategyM.resolveInterface(current), current);
 
 				String setterAttribute = "Content";
 				if (contentAttribute != null)
 				{
 					setterAttribute = contentAttribute;
 				}
 				objectStrategyM.setAttribute(current, setterAttribute, content);
 			}
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xml.sax.ContentHandler#endElement(java.lang.String,
 	 *      java.lang.String, java.lang.String)
 	 */
 	@Override
 	public void endElement(String arg0, String arg1, String elementName) throws SAXException
 	{
 		elementName = Util.capitalize(elementName);
 		if (elementName.equals(stackedElementM))
 		{
 			stackedElementM = null;
 			stackedMethodM = null;
 		}
 		else
 		{
 			stackM.pop();
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.xml.sax.ContentHandler#startElement(java.lang.String,
 	 *      java.lang.String, java.lang.String, org.xml.sax.Attributes)
 	 */
 	@Override
 	@SuppressWarnings("unchecked")
 	public void startElement(String arg0, String arg1, String elementName, Attributes attributes) throws SAXException
 	{
 		// get the current object
 		Object current = stackM.peek();
 		
 		// ensure first letter is uppercase
 		elementName = Util.capitalize(elementName);
 //		elementName = objectStrategyM.resolveElement(current, elementName);
 
 
 		Class currentType = objectStrategyM.resolveInterface(current);
 
 		//
 		// If the names do not match this is a sub element of the current.
 		// If the sub element is part of a Collection or Map it gets added
 		//
 		if (!currentType.getSimpleName().equals(elementName))
 		{
 			Method method = getGetterMethod(elementName, currentType);
 			if (method != null)
 			{
 				if (Collection.class.isAssignableFrom(method.getReturnType()))
 				{
 					try
 					{
 						//
 						// Obtain class type of elements within the collection
 						//
 						currentType = annotationStrategyM.getGenericReturnType(method);
 						if (currentType == null)
 						{
 							throw new IllegalArgumentException(
 									"Method "
 											+ method.getName()
 											+ " is not annotated and returns an object derived from java.util.Collection. Please annotate method with ReturnTypeAnnotation!");
 						}
 
 						//
 						// Create instance and store it in collection
 						//
 						Collection collection = (Collection) method.invoke(current, NO_PARAMETERS);
 						current = objectStrategyM.createInstance(currentType);
 
 						collection.add(current);
 						stackM.push(current);
 					}
 					catch (Throwable e)
 					{
 						throw new IllegalStateException("Error while adding to collection", e);
 					}
 
 				}
 				else if (Map.class.isAssignableFrom(method.getReturnType()))
 				{
 					try
 					{
 						//
 						// Obtain class type of elements within the collection
 						//                    	
 						currentType = annotationStrategyM.getGenericReturnType(method);
 						if (currentType == null)
 						{
 							throw new IllegalArgumentException(
 									"Method "
 											+ method.getName()
 											+ " is not annotated and returns an object derived from java.util.Collection. Please annotate method with ReturnTypeAnnotation!");
 						}
 
 						//
 						// Create instance and store it in map
 						// To store it, we need to obtain the mapping key
 						//                        
 						Map map = (Map) method.invoke(current, NO_PARAMETERS);
 						current = objectStrategyM.createInstance(currentType);
 						String attribute = annotationStrategyM.getKeyAttribute(method);
 
 						// TODO: enable key types other than String
 						map.put(attributes.getValue(attribute), current);
 						stackM.push(current);
 					}
 					catch (Throwable e)
 					{
 						throw new IllegalStateException("Error while adding to map", e);
 					}
 				}
 				else if (method.getReturnType().isInterface())
 				{
 					Object target = current;
 					currentType = method.getReturnType();
 					current = objectStrategyM.createInstance(currentType);
 					objectStrategyM.setAttribute(target, elementName, current);
 					stackM.push(current);
 				}
 				else
 				{
 					//
 					// seems that a non tagged value is not represented as
 					// attribute but
 					// as a subtag. i.e.
 					// instead of <currentObject myInt="42">...
 					// the stream reads
 					// <currentObject ....>
 					// <myInt>42</myInt>
 					//
 					// The interface seems to have the method int
 					// <currentObject>.getMyInt()
 					// So now we stack method and element for the
 					// characters.method
 					//
 					stackedMethodM = method;
 					stackedElementM = elementName;
 				}
 			}
 		}
 		setAttributesOfCurrentObject(attributes, current, currentType);
 	}
 
 	/***
 	 * Looks up the getter method for the current paramter type
 	 * 
 	 * @param elementName
 	 * @param currentType
 	 * 
 	 * @return The getter method for the current paramter type
 	 */
 	private Method getGetterMethod(String elementName, Class currentType)
 	{
 		String key = currentType.getName() + "." + elementName;
 		// System.out.println(key);
 		Method method = methodCacheM.get(key);
 		if (method == null)
 		{
 			String methodName = objectStrategyM.getMethodName(currentType, elementName, false);
 			if (methodName == null)
 			{
 				methodName = "get" + elementName;
 			}
 			try
 			{
 				method = currentType.getMethod(methodName, new Class[0]);
 			}
 			catch (Throwable e)
 			{
 				try
 				{
 					method = currentType.getMethod("get" + elementName + "s", new Class[0]);
 				}
 				catch (Throwable e1)
 				{
 					System.err.println("Could not find getter for attribute <" + elementName + ">");
 				}
 			}
 
 			if (method != null)
 			{
 				methodCacheM.put(key, method);
 			}
 		}
 		return method;
 	}
 
 	/***
 	 * Sets the attributes of the current object
 	 * 
 	 * @param attributes
 	 * @param current
 	 * @param currentType
 	 */
 	private void setAttributesOfCurrentObject(Attributes attributes, Object current, Class currentType)
 	{
 		try
 		{
 			List<Method> validMethods = validMethodsCacheM.get(currentType);
 			if (validMethods == null)
 			{
 				//
 				//	This caching halves the used time!
 				//
 				String methodName = null;
 				validMethods = new ArrayList<Method>();
 				validMethodsCacheM.put(currentType, validMethods);
 				
 				for (Method method : currentType.getMethods())
 				{
 					methodName = method.getName();
 					Class<?> returnType = method.getReturnType();
 					if (method.getParameterTypes().length == 0 && methodName.startsWith("get")
 							&& (returnType.isPrimitive() || returnType.getPackage().getName().equals("java.lang") // String, Integer					
 							|| Date.class.isAssignableFrom(returnType)))
 					{
 						validMethods.add(method);
 					}
 				}
 				
 			}
 			for (Method method : validMethods)
 			{
 				String methodName = method.getName();
 				Class<?> returnType = method.getReturnType();
 				String attributeName = methodName.substring(3, 4).toLowerCase() + methodName.substring(4);
 				String value = attributes.getValue(attributeName);
 				if (value != null)
 				{
 					Object typedValue = null;
 					if (returnType.isPrimitive())
 					{
 						typedValue = Util.getPrimitiveObject(returnType, value);
 					}
 					else if (Date.class.isAssignableFrom(returnType))
 					{
 						typedValue = dateHandlerM.getDateString(method, value);
 					}
 					else
 					{
 						typedValue = Util.createObject(returnType, value);
 					}
 
 					objectStrategyM.setAttribute(current, methodName.substring(3), typedValue);
 				}
 			}
 		}
 		catch (Throwable e)
 		{
 			e.printStackTrace();
 			throw new IllegalStateException("Error while applying attributes", e);
 		}
 
 	}
 
 }