/*
    * Copyright (c) 2007, James Leigh All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this
    *   list of conditions and the following disclaimer.
    * - Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution. 
   * - Neither the name of the openrdf.org nor the names of its contributors may
   *   be used to endorse or promote products derived from this software without
   *   specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * 
   */
  package org.openrdf.elmo.impl;
  
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Method;
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import javassist.CannotCompileException;
  import javassist.NotFoundException;
  
  import org.openrdf.elmo.ElmoMapperResolver;
  import org.openrdf.elmo.ElmoProperty;
  import org.openrdf.elmo.ElmoPropertyFactory;
  import org.openrdf.elmo.Entity;
  import org.openrdf.elmo.Mergeable;
  import org.openrdf.elmo.Refreshable;
  import org.openrdf.elmo.annotations.inverseOf;
  import org.openrdf.elmo.annotations.rdf;
  import org.openrdf.elmo.dynacode.ClassFactory;
  import org.openrdf.elmo.dynacode.ClassTemplate;
  import org.openrdf.elmo.dynacode.CodeBuilder;
  import org.openrdf.elmo.exceptions.ElmoCompositionException;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Properties that have the rdf or localname annotation are replaced with
   * getters and setters that access the Sesame Repository directly.
   * 
   * @author James Leigh
   * 
   */
  public class ElmoMapperClassFactory implements ElmoMapperResolver {
  	private static final String PROPERTY_SUFFIX = "Property";
  
  	private static final String FACTORY_SUFFIX = "Factory";
  
  	private static final String SET_PROPERTY_DESCRIPTOR = "setPropertyDescriptor";
  
  	private static final String CREATE_ELMO_PROPERTY = "createElmoProperty";
  
  	private static final String CLASS_PREFIX = "elmobeans.mappers.";
  
  	private static final String BEAN_FIELD_NAME = "_$elmoBean";
  
  	private static final String GET_ALL = "getAll";
  
  	private static final String GET_SINGLE = "getSingle";
  
  	private static final String SET_ALL = "setAll";
  
  	private static final String SET_SINGLE = "setSingle";
  
  	private final Logger logger = LoggerFactory
  			.getLogger(ElmoMapperClassFactory.class);
  
  	private ClassFactory cp;
  
  	private Class<?> propertyFactoryClass;
  
  	public ElmoMapperClassFactory() {
  	}
  
  	public void setClassDefiner(ClassFactory definer) {
  		this.cp = definer;
  	}
 
 	@SuppressWarnings("unchecked")
 	public void setElmoPropertyFactoryClass(
 			Class<? extends ElmoPropertyFactory> propertyFactoryClass) {
 		this.propertyFactoryClass = propertyFactoryClass;
 	}
 
 	public Collection<Class<?>> findMappers(Collection<Class<?>> interfaces) {
 		try {
 			Set<Class<?>> faces = new HashSet<Class<?>>();
 			for (Class<?> i : interfaces) {
 				faces.add(i);
 				faces = getInterfaces(i, faces);
 			}
 			List<Class<?>> mappers = new ArrayList<Class<?>>();
 			for (Class<?> concept : faces) {
 				if (isRdfPropertyPresent(concept)) {
 					mappers.add(findBehaviour(concept));
 				}
 			}
 			return mappers;
 		} catch (ElmoCompositionException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new ElmoCompositionException(e);
 		}
 	}
 
 	private Class<?> findBehaviour(Class<?> concept) throws Exception {
 		String className = getJavaClassName(concept);
 		try {
 			return Class.forName(className, true, cp);
 		} catch (ClassNotFoundException e1) {
 			synchronized (cp) {
 				try {
 					return Class.forName(className, true, cp);
 				} catch (ClassNotFoundException e2) {
 					return implement(className, concept);
 				}
 			}
 		}
 	}
 
 	private boolean isRdfPropertyPresent(Class<?> concept) {
 		for (Method m : concept.getDeclaredMethods()) {
 			if (m.isAnnotationPresent(rdf.class))
 				return true;
 		}
 		return false;
 	}
 
 	private String getJavaClassName(Class<?> concept) {
 		String cn = concept.getName();
 		return CLASS_PREFIX + cn + "Mapper";
 	}
 
 	private Class<?> implement(String className, Class<?> concept)
 			throws Exception {
 		ClassTemplate cc;
 		HashSet<Class<?>> interfaces = new HashSet<Class<?>>();
 		assert concept.isInterface();
 		interfaces.add(concept);
 		cc = cp.createClassTemplate(className);
 		cc.addInterface(Mergeable.class);
 		cc.addInterface(Refreshable.class);
 		addNewConstructor(cc);
 		enhance(cc, concept);
 		return cp.createClass(cc);
 	}
 
 	private Set<Class<?>> getInterfaces(Class<?> concept,
 			Set<Class<?>> interfaces) throws NotFoundException {
 		for (Class<?> face : concept.getInterfaces()) {
 			if (!interfaces.contains(face)) {
 				interfaces.add(face);
 				getInterfaces(face, interfaces);
 			}
 		}
 		return interfaces;
 	}
 
 	private void addNewConstructor(ClassTemplate cc) throws NotFoundException,
 			CannotCompileException {
 		cc.createField(Entity.class, BEAN_FIELD_NAME);
 		cc.addConstructor(new Class<?>[] { Entity.class }, BEAN_FIELD_NAME + " = $1;");
 	}
 
 	private void enhance(ClassTemplate cc, Class<?> concept) throws Exception {
 		for (Method method : concept.getDeclaredMethods()) {
 			if (method.isAnnotationPresent(rdf.class)
 					|| method.isAnnotationPresent(inverseOf.class)) {
 				if (method.getParameterTypes().length == 0) {
 					overrideMethod(method, cc);
 				} else {
 					String msg = "@rdf and @inverseOf annotations should only be on getter methods: {}#{}";
 					logger.warn(msg, concept.getSimpleName(), method.getName());
 				}
 			}
 		}
 		overrideMergeMethod(cc, concept);
 		overrideRefreshMethod(cc, concept);
 	}
 
 	private void overrideMergeMethod(ClassTemplate cc, Class<?> concept)
 			throws Exception {
 		Method merge = Mergeable.class.getMethod("merge", Object.class);
 		CodeBuilder sb = cc.overrideMethod(merge);
 		sb.code("if($1 instanceof ").code(concept.getName());
 		sb.code("){\n");
 		for (Method method : concept.getDeclaredMethods()) {
 			if (method.isAnnotationPresent(rdf.class)) {
 				String property = getPropertyName(method);
 				Method setter = getSetterMethod(property, method);
 				if (setter == null)
 					continue;
 				if (method.getReturnType().isPrimitive()) {
 					sb.code(setter.getName());
 					sb.code("(").code("((").code(concept.getName());
 					sb.code(") $1).").code(method.getName());
 					sb.code("()").code(");\n");
 				} else {
 					sb.declareObject(method.getReturnType(), property + "Var");
 					sb.code("((").code(concept.getName());
 					sb.code(") $1).").code(method.getName());
 					sb.code("();\n");
 					// array != null does not seem to work in javassist
 					sb.code("if(");
 					sb.codeInstanceof(property + "Var", method.getReturnType());
 					sb.code("){");
 					sb.code(setter.getName());
 					sb.code("(").code(property).code("Var);}\n");
 				}
 			}
 		}
 		sb.code("}").end();
 	}
 
 	private void overrideRefreshMethod(ClassTemplate cc, Class<?> concept)
 			throws Exception {
 		Method refresh = Refreshable.class.getMethod("refresh");
 		CodeBuilder sb = cc.overrideMethod(refresh);
 		for (String field : cc.getDeclaredFieldNames()) {
 			if (field.endsWith(PROPERTY_SUFFIX)) {
 				sb.code("if (").code(field).code(" != null) {");
 				sb.code(field).code(".refresh();}\n");
 			}
 		}
 		sb.end();
 	}
 
 	private void overrideMethod(Method method, ClassTemplate cc) throws Exception {
 		String property = getPropertyName(method);
 		Method setter = getSetterMethod(property, method);
 		Class<?> type = method.getReturnType();
 		String field = createPropertyField(property, cc);
 		String factory = createFactoryField(property, method, setter, cc);
 		CodeBuilder body = cc.overrideMethod(method);
 		appendNullCheck(body, field, factory, method, cc);
 		appendGetterMethod(body, field, type, method, cc);
 		body.end();
 		if (setter != null) {
 			body = cc.overrideMethod(setter);
 			appendNullCheck(body, field, factory, method, cc);
 			appendSetterMethod(body, field, type, method, cc);
 			body.end();
 		}
 	}
 
 	private Method getSetterMethod(String property, Method getter) {
 		try {
 			StringBuilder smn = new StringBuilder();
 			smn.append("set").append(Character.toUpperCase(property.charAt(0)));
 			smn.append(property, 1, property.length());
 			Class<?> dc = getter.getDeclaringClass();
 			Class<?> rt = getter.getReturnType();
 			return dc.getDeclaredMethod(smn.toString(), rt);
 		} catch (NoSuchMethodException exc) {
 			return null;
 		}
 	}
 
 	private String getPropertyName(Method method) {
 		String name = method.getName();
 		for (int i = 0, n = name.length(); i < n; i++) {
 			char chr = name.charAt(i);
 			if (Character.isUpperCase(chr)) {
 				StringBuilder property = new StringBuilder(name.length() - i);
 				property.append(Character.toLowerCase(name.charAt(i)));
 				property.append(name, i + 1, name.length());
 				return property.toString();
 			}
 		}
 		throw new IllegalArgumentException();
 	}
 
 	private String createPropertyField(String property, ClassTemplate cc)
 			throws Exception {
 		StringBuilder name = new StringBuilder();
 		name.append("_$").append(property).append(PROPERTY_SUFFIX);
 		String fieldName = name.toString();
 		cc.createField(ElmoProperty.class, fieldName);
 		return fieldName;
 	}
 
 	private String createFactoryField(String property, Method method,
 			Method setter, ClassTemplate cc) throws Exception {
 		String setterName = setter == null? null:setter.getName();
 		Class<?> declaringClass = method.getDeclaringClass();
 		String getterName = method.getName();
 		Class<?> class1 = PropertyDescriptor.class;
 		Class<?> type = ElmoPropertyFactory.class;
 		String fieldName = "_$" + property + FACTORY_SUFFIX;
 		CodeBuilder code = cc.assignStaticField(type, fieldName);
 		code.construct(propertyFactoryClass);
 		code.code(".").code(SET_PROPERTY_DESCRIPTOR).code("(");
 		code.construct(class1, property, declaringClass, getterName, setterName);
 		code.code(")").end();
 		return fieldName;
 	}
 
 	private boolean isCollection(Class<?> type, Method method, ClassTemplate cc)
 			throws Exception {
 		return Set.class.equals(type);
 	}
 
 	public static Class<?> getClassType(Method method) {
 		return method.getReturnType();
 	}
 
 	public static Class<?> getContentClassType(Method method) {
 		Type[] types = getTypeArguments(method);
 		if (types == null || types.length != 1)
 			return null;
 		if (types[0] instanceof Class)
 			return (Class) types[0];
 		if (types[0] instanceof ParameterizedType)
 			return (Class) ((ParameterizedType) types[0]).getRawType();
 		return null;
 	}
 
 	public static Type[] getTypeArguments(Method method) {
 		Type type = method.getGenericReturnType();
 		if (type instanceof ParameterizedType)
 			return ((ParameterizedType) type).getActualTypeArguments();
 		return null;
 	}
 
 	public static Type[] getContentTypeArguments(Method method) {
 		Type[] types = getTypeArguments(method);
 		if (types == null || types.length != 1)
 			return null;
 		if (types[0] instanceof ParameterizedType)
 			return ((ParameterizedType) types[0]).getActualTypeArguments();
 		return null;
 	}
 
 	private CodeBuilder appendNullCheck(CodeBuilder body, String field,
 			String propertyFactory, Method method, ClassTemplate cc)
 			throws Exception {
 		body.code("if (").code(field).code(" == null) {");
 		body.assign(field).code(propertyFactory);
 		body.code(".").code(CREATE_ELMO_PROPERTY);
 		body.code("(").code(BEAN_FIELD_NAME).code(");}");
 		return body;
 	}
 
 	private CodeBuilder appendGetterMethod(CodeBuilder body, String field,
 			Class<?> type, Method method, ClassTemplate cc) throws Exception {
 		if (isCollection(type, method, cc)) {
 			body.code("return ").code(field);
 			body.code(".").code(GET_ALL);
 			body.code("();");
 		} else if (type.isPrimitive()) {
 			body.declareObject(type, "result");
 			body.castObject(field, type);
 			body.code(".").code(GET_SINGLE);
 			body.code("();");
 			body.code("if (result != null) ");
 			body.code("return result.").code(type.getName()).code("Value();");
 			if (Boolean.TYPE.equals(type)) {
 				body.code("return false;");
 			} else {
 				body.code("return ($r) 0;");
 			}
 		} else {
 			body.code("return ");
 			body.castObject(field, type);
 			body.code(".").code(GET_SINGLE);
 			body.code("();");
 		}
 		return body;
 	}
 
 	private CodeBuilder appendSetterMethod(CodeBuilder body, String field,
 			Class<?> type, Method method, ClassTemplate cc) throws Exception {
 		body.code(field).code(".");
 		if (isCollection(type, method, cc)) {
 			body.code(SET_ALL).code("($1);");
 		} else {
 			body.code(SET_SINGLE).code("(").codeObject("$1", type).code(");");
 		}
 		return body;
 	}
 }