/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: Helper.java
   * Created: 2007-12-15
   * Author: apohllo
   * $Id: Helper.java 2335 2009-01-13 16:40:16Z entrop $
   */
  
  package pl.edu.agh.cast.model.mapper.internal;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.eclipse.osgi.util.NLS;
  
  import pl.edu.agh.cast.model.mapper.Mappable;
  import pl.edu.agh.cast.model.mapper.annotation.MapAttribute;
  import pl.edu.agh.cast.model.mapper.annotation.MapLink;
  import pl.edu.agh.cast.model.mapper.annotation.Mapping;
  
  /**
   * Helper class for the mapper - contains methods processing reflection data.
   *
   * @author AGH CAST Team
   *
   */
  public class Helper {
  	private static Map<Class, Boolean> superMapped = new HashMap<Class, Boolean>();
  
  	private static Map<Class<Mappable>, LinkEntry[]> linkMap = new HashMap<Class<Mappable>, LinkEntry[]>();
  
  	private static HashMap<Class<Mappable>, AttributeEntry[]> attributeMap = new HashMap<Class<Mappable>, AttributeEntry[]>();
  
  	private static Map<Class, Map<String, String>> accessors = new HashMap<Class, Map<String, String>>();
  
  	private static Map<Class, Map<String, Method>> methods = new HashMap<Class, Map<String, Method>>();
  
  	private static Map<Class, String> mappingNames = new HashMap<Class, String>();
  
  	private static Map<Class, Constructor<Mappable>> constructors = new HashMap<Class, Constructor<Mappable>>();
  
  	// private static Map<String, Class> classes = new HashMap<String, Class>();
  
  	/**
  	 * Return default constructor for given class.
  	 *
  	 * @param klass
  	 *            The class
  	 * @return the default constructor
  	 */
  	public static Constructor<Mappable> getConstructor(Class<Mappable> klass) throws SecurityException,
  	        NoSuchMethodException {
  		Constructor<Mappable> result = constructors.get(klass);
  		if (result == null) {
  			result = klass.getConstructor(new Class[] {});
  			constructors.put(klass, result);
  		}
  		return result;
  	}
  
  	/**
  	 * Returns the name of the accessor (i.e. getter/setter name without "get/set") for the link with given name
  	 *
  	 * @param klass
  	 *            The klass for which the accessor is to be returned.
  	 * @param linkName
  	 *            The name of the link.
  	 * @return Accessor (getter/setter name without "get/set").
  	 */
  	public static String objectAccessor(Class klass, String linkName) {
  		// cut the "get" part of the name
  		String accessor = null;
  		Map<String, String> linkToAccessor = null;
  		if (accessors.containsKey(klass)) {
  			linkToAccessor = accessors.get(klass);
  			if (linkToAccessor.containsKey(linkName)) {
  				accessor = linkToAccessor.get(linkName);
  			} else {
  				accessor = getAnnotatedMethod(klass, linkName).getName().substring(3);
  				linkToAccessor.put(linkName, accessor);
  			}
  		} else {
  			accessor = getAnnotatedMethod(klass, linkName).getName().substring(3);
  			linkToAccessor = new HashMap<String, String>(5);
  			linkToAccessor.put(linkName, accessor);
  			accessors.put(klass, linkToAccessor);
 		}
 		return accessor;
 	}
 
 	/**
 	 * Get mapped type name for given class. By default the type name is the same as FQ class name, but it might be
 	 * different to allow polimorphic mapping
 	 *
 	 * @param klass
 	 *            The klass of the mapped object
 	 * @return Mapped type name
 	 */
 	public static String mappedTypeName(Class klass) {
 		if (mappingNames.containsKey(klass)) {
 			return mappingNames.get(klass);
 		}
 		String typeName = ((Mapping)klass.getAnnotation(Mapping.class)).value();
 		if (typeName == null || typeName.equals("")) {
 			typeName = klass.getCanonicalName();
 		}
 		mappingNames.put(klass, typeName);
 		return typeName;
 	}
 
 	/**
 	 * Return link data (MapLink annotation) for the given mappable and link with given name.
 	 *
 	 * @param klass
 	 *            The class where the link should be looked for.
 	 * @param linkName
 	 *            The name of the link
 	 * @return The MapLinkAnnotation
 	 */
 	public static MapLink getLinkData(Class klass, String linkName) {
 		return getAnnotatedMethod(klass, linkName).getAnnotation(MapLink.class);
 	}
 
 	/**
 	 * Return an annotated method whose annotation name is the given parameter.
 	 *
 	 * @param klass
 	 *            The class for which the method is returned.
 	 * @param linkName
 	 *            The name of the link.
 	 * @return The method which is annotaded as a link with given name.
 	 */
 	public static Method getAnnotatedMethod(Class klass, String linkName) {
 		Method method = null;
 		Map<String, Method> linkToAccessor = null;
 		if (methods.containsKey(klass)) {
 			linkToAccessor = methods.get(klass);
 			if (linkToAccessor.containsKey(linkName)) {
 				method = linkToAccessor.get(linkName);
 			} else {
 				method = getAnnotatedMethodInternal(klass, linkName);
 				linkToAccessor.put(linkName, method);
 			}
 		} else {
 			method = getAnnotatedMethodInternal(klass, linkName);
 			linkToAccessor = new HashMap<String, Method>(5);
 			linkToAccessor.put(linkName, method);
 			methods.put(klass, linkToAccessor);
 		}
 		return method;
 	}
 
 	/**
 	 * Internal version doesn't use cache
 	 *
 	 * @param klass
 	 * @param linkName
 	 * @return
 	 */
 	private static Method getAnnotatedMethodInternal(Class klass, String linkName) {
 		for (Method method : klass.getMethods()) {
 			if (method.isAnnotationPresent(MapLink.class)) {
 				if ((method.getAnnotation(MapLink.class)).name().equals(linkName)) {
 					return method;
 				}
 			}
 		}
 		throw new RuntimeException(NLS.bind("No data for link {0} for {1}", //$NON-NLS-1$
 		        linkName, klass));
 	}
 
 	/**
 	 * Find all methods which have the MapAttribute annotation present.
 	 *
 	 * @param klass
 	 *            Class which is searched for the methods
 	 * @return Methods which have the MapAttribute annotation present.
 	 */
 	public static Method[] mappedAttributeMethods(Class klass) {
 		Method[] methods1 = klass.getDeclaredMethods();
 		List<Method> result = new LinkedList<Method>();
 		for (Method method : methods1) {
 			if (method.isAnnotationPresent(MapAttribute.class)) {
 				result.add(method);
 			}
 		}
 		return result.toArray(new Method[0]);
 	}
 
 	/**
 	 * Find all methods which have the MapAttribute annotation present.
 	 *
 	 * @param klass
 	 *            Class which is searched for the methods
 	 * @return Methods which have the MapLink annotation present.
 	 */
 	public static Method[] mappedLinkMethods(Class klass) {
 		Method[] methods1 = klass.getDeclaredMethods();
 		List<Method> result = new LinkedList<Method>();
 		for (Method method : methods1) {
 			if (method.isAnnotationPresent(MapLink.class)) {
 				result.add(method);
 			}
 		}
 		return result.toArray(new Method[0]);
 	}
 
 	/**
 	 * Checks if given class is mapped to metamodel.
 	 *
 	 * @param klass
 	 *            Checked class
 	 * @return True if the class is mapped.
 	 */
 	public static boolean isSuperMapped(Class klass) {
 		if (superMapped.containsKey(klass)) {
 			return superMapped.get(klass);
 		}
 		Class superClass = klass.getSuperclass();
 		if (superClass.equals(Object.class)) {
 			superMapped.put(klass, false);
 			return false;
 		}
 		Mapping mapping = (Mapping)superClass.getAnnotation(Mapping.class);
 		if (mapping != null) {
 			superMapped.put(klass, true);
 			return true;
 		} else {
 			superMapped.put(klass, false);
 			return false;
 		}
 
 	}
 
 	/**
 	 * Returns the setter methods. Walks through argument's class hierarchy (including implemented directly implemented
 	 * interfaces) trying to find the proper setter. If not found throws RuntimeException.
 	 *
 	 * @param object
 	 *            The object whose class is looked for the setter.
 	 * @param linkedElement
 	 *            The object whose class is used to determine the setters argument
 	 * @param setterName
 	 *            The name of the setter method (with set in it.)
 	 * @return Setter in class of object, which accepts linkedElement as argument.
 	 */
 	public static Method getSetter(Mappable object, Object linkedElement, String setterName) {
 		Class linkedElementClass = linkedElement.getClass();
 		Method setter = null;
 		while (!linkedElementClass.equals(Object.class)) {
 			try {
 				setter = object.getClass().getMethod(setterName, linkedElementClass);
 				return setter;
 			} catch (NoSuchMethodException ex) {
 				// do nothing
 			}
 			for (Class interf : linkedElementClass.getInterfaces()) {
 				try {
 					setter = object.getClass().getMethod(setterName, interf);
 					return setter;
 				} catch (NoSuchMethodException ex) {
 					// do nothing
 				}
 			}
 			linkedElementClass = linkedElementClass.getSuperclass();
 		}
 		throw new RuntimeException(NLS
 		        .bind("Setter not found: {0}.{1}({2})", //$NON-NLS-1$
 		                new Object[] { object.getClass().getSimpleName(), setterName,
 		                    linkedElement.getClass().getSimpleName() }));
 	}
 
 	/**
 	 * Get methods with MapLink annotations for the given class.
 	 *
 	 * @param klass
 	 *            The class for which methods with annotations are returned.
 	 * @return Array of pairs: method -- annotation
 	 */
 	public static LinkEntry[] getMappedLinks(Class<Mappable> klass) {
 		if (linkMap.containsKey(klass)) {
 			return linkMap.get(klass);
 		}
 		Method[] methods1 = Helper.mappedLinkMethods(klass);
 		LinkEntry[] entries = new LinkEntry[methods1.length];
 		for (int i = 0; i < entries.length; i++) {
 			entries[i] = new LinkEntry(methods1[i], methods1[i].getAnnotation(MapLink.class));
 		}
 		linkMap.put(klass, entries);
 		return entries;
 	}
 
 	/**
 	 * Get methods with MapAttribute annotations for the given class.
 	 *
 	 * @param klass
 	 *            The class for which methods with annotations are returned.
 	 * @return Array of pairs: method -- annotation
 	 */
 	public static AttributeEntry[] getMappedAttributes(Class<Mappable> klass) {
 		if (attributeMap.containsKey(klass)) {
 			return attributeMap.get(klass);
 		}
 		Method[] methods1 = Helper.mappedAttributeMethods(klass);
 		AttributeEntry[] entries = new AttributeEntry[methods1.length];
 		for (int i = 0; i < entries.length; i++) {
 			entries[i] = new AttributeEntry(methods1[i], methods1[i].getAnnotation(MapAttribute.class));
 		}
 		attributeMap.put(klass, entries);
 		return entries;
 	}
 
 	/**
 	 * Returns the class for given type name and type map.
 	 *
 	 * @param typeName
 	 *            The name of the type in base model.
 	 * @param typeMap
 	 *            The type map.
 	 * @return The class for given type name.
 	 * @throws ClassNotFoundException
 	 */
 	public static Class<Mappable> mappedClass(String typeName, Map<String, Class> typeMap)
 	        throws ClassNotFoundException {
 		Class<Mappable> klass = typeMap.get(typeName);
 		if (klass == null) {
 			klass = (Class<Mappable>)Class.forName(typeName);
 			typeMap.put(typeName, klass);
 		}
 		return klass;
 	}
 
 }