package ar.com.jiji.kaya.enhancer;
   
   import java.util.Set;
   
   import javassist.CannotCompileException;
   import javassist.ClassClassPath;
   import javassist.ClassPool;
   import javassist.CtClass;
   import javassist.CtMethod;
  import javassist.Modifier;
  import javassist.NotFoundException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import ar.com.jiji.kaya.reflect.ReflectionService;
  import ar.com.jiji.kaya.utils.ValidateUtils;
  
  /**
   * 
   */
  
  /**
   * Extiende cierta clase implementando los metodos abstractos que involucren
   * operaciones con los dao. Para poder usar esta clase debemos seguir un par de
   * convenciones. Si la implementacion del facade es abstracta, se busca si
   * alguno de estos metodos es una operacion de creacion/actualizacion o borrado
   * de alguna entidad. Los metodos de borrado deben ser de la forma
   * <code>removeX(long id)</code> y los de creacion/actualizacion
   * <code>saveX(&lt;X&gt; obj)</code>. Siendo <code>X</code> alguna entidad
   * del sistema. Al encontrar estos metodos se crea una subclase del facade que
   * implemente estos metodos, los cuales delegan su funcionalidad en
   * <code>DaoUtils</code>. <br/> Se usa en general durante la fase de
   * configuracion de la aplicacion por medio de Spring.
   * 
   * @author lparra
   * @version $Revision$ $Date$
   * @see ar.com.jiji.kaya.dao.DaoUtils
   */
  public class FacadeDaoEnhancer {
  	private static final Log log = LogFactory.getLog(FacadeDaoEnhancer.class);
  
  	private ClassPool pool;
  
  	private long id;
  
  	private static FacadeDaoEnhancer enhancer;
  
  	private FacadeDaoEnhancer() {
  		pool = ClassPool.getDefault();
  		pool.insertClassPath(new ClassClassPath(this.getClass()));
  	}
  
  	public static synchronized FacadeDaoEnhancer getInstance() {
  		if (enhancer == null)
  			enhancer = new FacadeDaoEnhancer();
  		return enhancer;
  	}
  
  	/**
  	 * Se usa para obtener un numero unico para agregarle al nombre de la clase
  	 * generada.
  	 * 
  	 * @return
  	 */
  	private synchronized String nextSequence() {
  		// TODO cuando haya overflow, (para lo cual tiene que haber muuchas
  		// clases creadas) va a tirar excepcion de frozen class
  		id++;
  		return System.currentTimeMillis() + "_" + id;
  	}
  
  	/**
  	 * Crea una subclase de la clase abstracta especificada e implementa los
  	 * metodos abstractos para las operaciones de los dao.
  	 * 
  	 * @param clazz
  	 *            La clase a inspeccionar. Puede ser una interfaz.
  	 * @param modelPkg
  	 *            El nombre del paquete donde estan las clases del modelo.
  	 *            FIXME: Esto supone todos los objetos del dominio en el mismo
  	 *            paquete y no es asi. Ver como solucionarlo.
  	 * @return La subclase. Devuelve la misma clase si no es abstracta.
  	 * @throws EnhancerException
  	 */
  	public Class enhance(Class clazz, String modelPkg) throws EnhancerException {
  		ValidateUtils.argNotNull(clazz, "clase");
  
  		CtClass cImpl;
  		try {
  			cImpl = getCtClass(clazz);
  
  			int m = cImpl.getModifiers();
  			if (Modifier.isAbstract(m)) {
  				CtClass cEnhanced = createConcreteClass(clazz, modelPkg, cImpl);
  				return cEnhanced.toClass();
  			}
  			log.info(clazz + " no es abstracta");
  			return clazz;
 		} catch (NotFoundException e) {
 			throw new EnhancerException(e);
 		} catch (CannotCompileException e) {
 			throw new EnhancerException(e);
 		} catch (ClassNotFoundException e) {
 			throw new EnhancerException(e);
 		}
 	}
 
 	private CtClass createConcreteClass(Class clazz, String modelPkg,
 			CtClass cImpl) throws NotFoundException, ClassNotFoundException,
 			ClassNotFoundException, CannotCompileException {
 		int m = cImpl.getModifiers();
 		CtClass superClass;
 		if (Modifier.isInterface(m))
 			superClass = getCtClass("java.lang.Object");
 		else
 			superClass = cImpl;
 		// TODO tomar en cuenta si tiene paquetes
 		CtClass cEnhanced = pool.makeClass("Enhanced" + clazz.getSimpleName()
 				+ "_" + nextSequence(), superClass);
 		if (Modifier.isInterface(m))
 			cEnhanced.addInterface(cImpl);
 		addMissingMethods(cEnhanced, modelPkg);
 		return cEnhanced;
 	}
 
 	private CtClass getCtClass(String className) throws NotFoundException {
 		return pool.get(className);
 	}
 
 	private void addMissingMethods(CtClass clazz, String modelPkg)
 			throws NotFoundException, CannotCompileException,
 			ClassNotFoundException {
 		CtMethod[] implMethods = clazz.getMethods();
 		for (CtMethod method : implMethods) {
 			if (Modifier.isAbstract(method.getModifiers())) {
 				log.debug("adding " + method.getName());
 				addMissingMethod(clazz, method, modelPkg);
 			}
 		}
 	}
 
 	private void addMissingMethod(CtClass clazz, CtMethod method,
 			String modelPkg) throws NotFoundException, CannotCompileException,
 			ClassNotFoundException {
 		if (isRemoveMethod(method))
 			addRemoveMethod(clazz, method, modelPkg);
 		if (isSaveMethod(method))
 			addSaveMethod(clazz, method, modelPkg);
 	}
 
 	private void addSaveMethod(CtClass clazz, CtMethod method, String modelPkg)
 			throws NotFoundException, CannotCompileException,
 			ClassNotFoundException {
 		String className = modelPkg + "." + getModelName(method);
 		CtMethod newMethod = new CtMethod(getCtClass(void.class), method
 				.getName(),
 				new CtClass[] { getCtClass(Class.forName(className)) }, clazz);
 		newMethod.setBody("{ "
 				+ "ar.com.jiji.kaya.dao.DaoUtils.save(getService(), "
 				+ "Class.forName(\"" + className + "\"), $1);}");
 
 		newMethod.setModifiers(Modifier.PUBLIC);
 		clazz.addMethod(newMethod);
 	}
 
 	private void addRemoveMethod(CtClass clazz, CtMethod method, String modelPkg)
 			throws CannotCompileException, NotFoundException {
 		CtMethod newMethod = new CtMethod(getCtClass(void.class), method
 				.getName(), new CtClass[] { getCtClass(Set.class) }, clazz);
 		String className = modelPkg + "." + getModelName(method);
 		newMethod.setBody("{ "
 				+ "ar.com.jiji.kaya.dao.DaoUtils.remove(getService(), "
 				+ "Class.forName(\"" + className + "\"), $1);}");
 
 		newMethod.setModifiers(Modifier.PUBLIC);
 		clazz.addMethod(newMethod);
 	}
 
 	private CtClass getCtClass(Class clazz) throws NotFoundException {
 		return getCtClass(clazz.getName());
 	}
 
 	private boolean isRemoveMethod(CtMethod method) throws NotFoundException {
 		return (matchRemoveName(method) && matchRemoveReturnType(method) && matchRemoveArgs(method));
 	}
 
 	private boolean matchRemoveArgs(CtMethod method) throws NotFoundException {
 		CtClass[] args = method.getParameterTypes();
 		return args.length == 1
 				&& args[0].getName().equals(Set.class.getName());
 	}
 
 	private boolean matchRemoveReturnType(CtMethod method)
 			throws NotFoundException {
 		return method.getReturnType().getName().equals("void");
 	}
 
 	private boolean matchRemoveName(CtMethod method) {
 		String name = method.getName();
 		return name.startsWith("remove") && name.length() > 6;
 	}
 
 	private boolean matchSaveName(CtMethod method) {
 		String name = method.getName();
 		return name.startsWith("save") && name.length() > 4;
 	}
 
 	private String getModelName(CtMethod method) {
 		String result = null;
 		if (matchRemoveName(method))
 			result = method.getName().substring(6);
 		else if (matchSaveName(method))
 			result = method.getName().substring(4);
 		return result;
 	}
 
 	private boolean isSaveMethod(CtMethod method) throws NotFoundException {
 		String name = method.getName();
 		return (name.startsWith("save") && name.length() > 4
 				&& method.getReturnType().getName().equals("void") && method
 				.getParameterTypes().length == 1);
 	}
 
 	/**
 	 * Implementa los metodos abstractos de la clase e instancia la clase.
 	 * 
 	 * @param c
 	 * @param model
 	 * @return
 	 * @see #enhance(Class, String)
 	 */
 	public Object enhanceAndInstance(Class c, String model) {
 		Class enhanced = enhance(c, model);
 		return ReflectionService.newInstance(enhanced);
 	}
 }