/*
    * 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 static java.lang.reflect.Modifier.isAbstract;
  
  import java.lang.reflect.Method;
  import java.security.AccessControlException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeSet;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import org.openrdf.elmo.ElmoEntityResolver;
  import org.openrdf.elmo.ImplementationResolver;
  import org.openrdf.elmo.annotations.factory;
  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;
  
  /**
   * This class takes a collection of roles (interfaces or classes) and uses
   * composition to combine this into a single class.
   * 
   * @author James Leigh
   * 
   */
  public class ElmoEntityCompositor implements ElmoEntityResolver {
  	private static final String _$INTERCEPTED = "_$intercepted";
  	private static final String PKG_PREFIX = "elmobeans.proxies._$";
  	private static final String CLASS_PREFIX = "_$EntityProxy";
  	private Logger logger = LoggerFactory.getLogger(ElmoEntityCompositor.class);
  	private Set<String> special = new HashSet<String>(Arrays.asList(
  			"groovy.lang.GroovyObject"));
  	private ImplementationResolver interfaceResolver;
  	private ImplementationResolver abstractResolver;
  	private ClassFactory cp;
  	private ConcurrentMap<List<Class<?>>, Class<?>> classes;
  
  	public ElmoEntityCompositor() {
  		classes = new ConcurrentHashMap<List<Class<?>>, Class<?>>();
  	}
  
  	public void setInterfaceBehaviourResolver(ImplementationResolver loader) {
  		this.interfaceResolver = loader;
  	}
  
  	public void setAbstractBehaviourResolver(ImplementationResolver loader) {
  		this.abstractResolver = loader;
  	}
  
  	public void setClassDefiner(ClassFactory definer) {
  		this.cp = definer;
  	}
  
  	public Class<?> resolveRoles(Class<?>[] roles) {
  		List<Class<?>> list = Arrays.asList(roles);
  		Class<?> type = classes.get(list);
  		if (type == null) {
  			type = createClass(list);
  			Class<?> o = classes.putIfAbsent(list, type);
  			if (o != null) {
 				type = o;
 			}
 		}
 		return type;
 	}
 
 	private Class<?> createClass(List<Class<?>> roles) {
 		try {
 			List<Class<?>> types = new ArrayList<Class<?>>(roles);
 			types = removeSuperClasses(types);
 			Set<Class<?>> interfaces = new HashSet<Class<?>>(types.size());
 			Set<Class<?>> abstracts = new HashSet<Class<?>>(types.size());
 			Set<Class<?>> behaviours = new LinkedHashSet<Class<?>>(types.size());
 			Map<Class<?>, MethodFactory> map = new HashMap();
 			for (Class<?> role : types) {
 				if (role.isAnnotationPresent(factory.class)) {
 					for (Method m : role.getMethods()) {
 						if (m.isAnnotationPresent(factory.class)) {
 							map.put(m.getReturnType(), new MethodFactory(m,
 									role));
 						}
 					}
 				}
 			}
 			for (Class<?> role : types) {
 				if (role.isAnnotationPresent(factory.class))
 					continue;
 				if (role.isInterface()) {
 					interfaces.add(role);
 				} else if (isAbstract(role.getModifiers())) {
 					abstracts.add(role);
 				} else {
 					behaviours.add(role);
 				}
 				if (map.containsKey(role)) {
 					behaviours.add(role);
 				}
 			}
 			behaviours.addAll(abstractResolver.findImplementations(abstracts));
 			behaviours.addAll(interfaceResolver.findImplementations(abstracts));
 			behaviours.addAll(interfaceResolver.findImplementations(interfaces));
 			String className = getJavaClassName(roles);
 			return getComposedBehaviours(className, interfaces, behaviours, map);
 		} catch (Exception e) {
 			List<String> roleNames = new ArrayList<String>();
 			for (Class<?> f : roles) {
 				roleNames.add(f.getSimpleName());
 			}
 			throw new ElmoCompositionException(e.getMessage()
 					+ " for entity with roles: " + roleNames, e);
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	private List<Class<?>> removeSuperClasses(List<Class<?>> classes) {
 		for (int i = classes.size() - 1; i >= 0; i--) {
 			Class<?> c = classes.get(i);
 			for (int j = classes.size() - 1; j >= 0; j--) {
 				Class<?> d = classes.get(j);
 				if (i != j && c.isAssignableFrom(d)) {
 					classes.remove(i);
 					break;
 				}
 			}
 		}
 		return classes;
 	}
 
 	private Class<?> getComposedBehaviours(String className,
 			Set<Class<?>> interfaces, Set<Class<?>> javaClasses,
 			Map<Class<?>, MethodFactory> factories) throws Exception {
 		try {
 			return Class.forName(className, true, cp);
 		} catch (ClassNotFoundException e) {
 			synchronized (cp) {
 				try {
 					return Class.forName(className, true, cp);
 				} catch (ClassNotFoundException e1) {
 					return composeBehaviours(className, interfaces,
 							javaClasses, factories);
 				}
 			}
 		}
 	}
 
 	private Class<?> composeBehaviours(String className,
 			Set<Class<?>> interfaces, Set<Class<?>> javaClasses,
 			Map<Class<?>, MethodFactory> factories) throws Exception {
 		List<Behaviour> behaviours = new ArrayList<Behaviour>();
 		ClassTemplate cc = cp.createClassTemplate(className);
 		for (Class<?> clazz : javaClasses) {
 			addInterfaces(clazz, interfaces);
 		}
 		for (Class<?> face : interfaces) {
 			cc.addInterface(face);
 		}
 		for (Class<?> clazz : javaClasses) {
 			Behaviour behaviour = new Behaviour();
 			behaviour.setJavaClass(clazz);
 			behaviour.setDeclaring(cc);
 			behaviour.setFactories(factories);
 			behaviour.init();
 			behaviours.add(behaviour);
 		}
 		for (Method method : getMethods(javaClasses)) {
 			if (!method.getName().startsWith("_$")) {
 				Class<?> face = findInterface(method, cc.getInterfaces());
 				if (face == null)
 					face = method.getDeclaringClass();
 				List<Behaviour> incepts = getInterceptors(behaviours, method,
 						face, cc);
 				if (incepts.size() > 0) {
 					String name = _$INTERCEPTED + method.getName();
 					if (implementMethod(behaviours, method, name, cc)) {
 						interceptMethod(incepts, method, name, face, cc);
 					}
 				} else {
 					implementMethod(behaviours, method, method.getName(), cc);
 				}
 			}
 		}
 		return cp.createClass(cc);
 	}
 
 	private Collection<Method> getMethods(Set<Class<?>> javaClasses) {
 		Map map = new HashMap();
 		for (Class<?> jc : javaClasses) {
 			for (Method m : jc.getMethods()) {
 				if (isSpecial(m))
 					continue;
 				List list = new ArrayList(m.getParameterTypes().length + 1);
 				list.add(m.getName());
 				list.addAll(Arrays.asList(m.getParameterTypes()));
 				if (!map.containsKey(list)) {
 					map.put(list, m);
 				}
 			}
 		}
 		return map.values();
 	}
 
 	private Set<Class<?>> addInterfaces(Class<?> clazz, Set<Class<?>> interfaces) {
 		if (interfaces.contains(clazz))
 			return interfaces;
 		if (clazz.isInterface()) {
 			interfaces.add(clazz);
 		}
 		Class<?> superclass = clazz.getSuperclass();
 		if (superclass != null) {
 			addInterfaces(superclass, interfaces);
 		}
 		for (Class<?> face : clazz.getInterfaces()) {
 			if (!isSpecial(face)) {
 				addInterfaces(face, interfaces);
 			}
 		}
 		return interfaces;
 	}
 
 	private boolean isSpecial(Method m) {
 		return Object.class.equals(m.getDeclaringClass());
 	}
 
 	private boolean isSpecial(Class<?> face) {
 		return special.contains(face.getName());
 	}
 
 	private String getJavaClassName(Collection<Class<?>> javaClasses) {
 		String phex = packagesToHexString(javaClasses);
 		String chex = classesToHexString(javaClasses);
 		return PKG_PREFIX + phex + "." + CLASS_PREFIX + chex;
 	}
 
 	private String packagesToHexString(Collection<Class<?>> javaClasses) {
 		TreeSet<String> names = new TreeSet<String>();
 		for (Class<?> clazz : javaClasses) {
 			names.add(clazz.getPackage().getName());
 		}
 		return toHexString(names);
 	}
 
 	private String classesToHexString(Collection<Class<?>> javaClasses) {
 		TreeSet<String> names = new TreeSet<String>();
 		for (Class<?> clazz : javaClasses) {
 			names.add(clazz.getName());
 		}
 		return toHexString(names);
 	}
 
 	private String toHexString(TreeSet<String> names) {
 		long hashCode = 0;
 		for (String name : names) {
 			hashCode = 31 * hashCode + name.hashCode();
 		}
 		return Long.toHexString(hashCode);
 	}
 
 	private boolean implementMethod(List<Behaviour> behaviours, Method method,
 			String name, ClassTemplate cc) throws Exception {
 		Class<?> type = method.getReturnType();
 		boolean voidReturnType = type.equals(Void.TYPE);
 		boolean booleanReturnType = type.equals(Boolean.TYPE);
 		boolean primitiveReturnType = type.isPrimitive();
 		StringBuilder body = new StringBuilder();
 		if (!voidReturnType && primitiveReturnType) {
 			body.append(type.getName()).append(" result;");
 		} else if (!voidReturnType) {
 			body.append("Object result;");
 		}
 		int implemented = 0;
 		StringBuilder eval = null;
 		for (Behaviour behaviour : behaviours) {
 			if (behaviour.isMethodPresent(method)) {
 				implemented++;
 				if (!voidReturnType)
 					body.append("result = ");
 				eval = new StringBuilder();
 				eval.append(behaviour.getGetterName()).append("()");
 				eval.append(".").append(method.getName()).append("($$);");
 				body.append(eval);
 				if (booleanReturnType) {
 					body.append("if (result) return result;");
 				} else if (!voidReturnType && primitiveReturnType) {
 					body.append("if (result != 0) return ($r) result;");
 				} else if (!voidReturnType) {
 					body.append("if (result != null) return ($r) result;");
 				}
 			}
 		}
 		if (!voidReturnType)
 			body.append("return ($r) result;");
 		if (implemented == 1 && eval != null) {
 			cc.createMethod(method.getReturnType(), name,
 					method.getParameterTypes()).code(
 					"return ($r) " + eval.toString()).end();
 			return true;
 		} else if (implemented > 1) {
 			cc.createMethod(method.getReturnType(), name,
 					method.getParameterTypes()).code(body.toString()).end();
 			return true;
 		}
 		return false;
 	}
 
 	private List<Behaviour> getInterceptors(List<Behaviour> behaviours,
 			Method method, Class<?> face, ClassTemplate cc) throws Exception {
 		List<Behaviour> result = new ArrayList<Behaviour>(behaviours.size());
 		for (Behaviour behaviour : behaviours) {
 			if (behaviour.invokeCondition(method, face)) {
 				result.add(behaviour);
 			}
 		}
 		return result;
 	}
 
 	private void interceptMethod(List<Behaviour> interceptors, Method method,
 			String name, Class<?> face, ClassTemplate cc) throws Exception {
 		CodeBuilder body = cc.overrideMethod(method);
 		body.code("return ($r) new ").code(
 				InvocationContextImpl.class.getName());
 		body.code("($0, ");
 		Method declaredMethod = face.getDeclaredMethod(method.getName(), method
 				.getParameterTypes());
 		body.insert(declaredMethod);
 		body.code(", $args, ");
 		body.insertMethod(name, method.getParameterTypes()).code(")");
 		for (Behaviour behaviour : interceptors) {
 			for (Method m : behaviour.getAroundInvoke(method, face, cc)) {
 				body.code(".appendInvocation(");
 				body.code(behaviour.getGetterName()).code("(), ");
 				body.insert(m);
 				body.code(")");
 			}
 		}
 		body.code(".proceed();");
 		body.end();
 	}
 
 	private Class<?> findInterface(Method method, Class<?>[] interfaces)
 			throws Exception {
 		Class<?> declaring = null;
 		for (Class<?> face : interfaces) {
 			try {
 				face.getDeclaredMethod(method.getName(), method
 						.getParameterTypes());
 				declaring = face;
 			} catch (AccessControlException e) {
 				logger.warn("Could not access " + face.getName(), e);
 				declaring = findInterface(method, face.getInterfaces());
 			} catch (NoSuchMethodException e) {
 				declaring = findInterface(method, face.getInterfaces());
 			}
 			if (declaring != null)
 				return declaring;
 		}
 		return declaring;
 	}
 }