package org.openrdf.elmo.dynacode;
   
   import java.lang.reflect.Method;
   import java.util.HashSet;
   import java.util.Set;
   
   import javassist.CannotCompileException;
   import javassist.CtClass;
   import javassist.CtConstructor;
  import javassist.CtField;
  import javassist.CtMethod;
  import javassist.CtNewMethod;
  import javassist.Modifier;
  import javassist.NotFoundException;
  
  import org.openrdf.elmo.exceptions.ElmoCompositionException;
  
  public class ClassTemplate {
  
  	private CodeBuilder cb;
  
  	private CtClass cc;
  
  	private ClassFactory cp;
  
  	protected ClassTemplate(final CtClass cc, final ClassFactory cp) {
  		this.cc = cc;
  		this.cp = cp;
  		this.cb = new CodeBuilder(this, cp) {
  			@Override
  			public CodeBuilder end() {
  				try {
  					semi();
  					cc.makeClassInitializer().insertAfter(toString());
  				} catch (CannotCompileException e) {
  					throw new ElmoCompositionException(e.getMessage() + " for "
  							+ toString(), e);
  				}
  				clear();
  				return this;
  			}
  		};
  	}
  
  	public void addConstructor(Class<?>[] types, String string)
  			throws ElmoCompositionException {
  		try {
  			CtConstructor con = new CtConstructor(asCtClassArray(types), cc);
  			con.setBody(string);
  			cc.addConstructor(con);
  		} catch (CannotCompileException e) {
  			throw new ElmoCompositionException(e);
  		} catch (NotFoundException e) {
  			throw new ElmoCompositionException(e);
  		}
  	}
  
  	public void addInterface(Class<?> face) throws ElmoCompositionException {
  		cc.addInterface(cp.get(face));
  	}
  
  	public CodeBuilder assignStaticField(Class<?> type, final String fieldName)
  			throws ElmoCompositionException {
  		try {
  			CtField field = new CtField(cp.get(type), fieldName, cc);
  			field.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
  			cc.addField(field);
  		} catch (CannotCompileException e) {
  			throw new ElmoCompositionException(e);
  		}
  		CodeBuilder code = new CodeBuilder(this, cp) {
  			@Override
  			public CodeBuilder end() {
  				semi();
  				return cb.code(toString()).end();
  			}
  		};
  		return code.assign(fieldName);
  	}
  
  	public void createField(Class<?> type, String fieldName)
  			throws ElmoCompositionException {
  		try {
  			CtField field = new CtField(cp.get(type), fieldName, cc);
  			field.setModifiers(Modifier.PRIVATE);
  			cc.addField(field);
  		} catch (CannotCompileException e) {
  			throw new ElmoCompositionException(e);
  		}
  	}
  
  	public CodeBuilder createMethod(Class<?> type, String name,
  			Class<?>... parameters) throws ElmoCompositionException {
  		CtClass[] exces = new CtClass[] { cp.get(Throwable.class) };
  		try {
  			return begin(CtNewMethod.make(cp.get(type), name,
  					asCtClassArray(parameters), exces, null, cc));
  		} catch (CannotCompileException e) {
  			throw new ElmoCompositionException(e);
 		} catch (NotFoundException e) {
 			throw new ElmoCompositionException(e);
 		}
 	}
 
 	public CodeBuilder createTransientMethod(Class<?> type, String name,
 			Class<?>... parameters) throws ElmoCompositionException {
 		CtClass[] exces = new CtClass[] { cp.get(Throwable.class) };
 		try {
 			CtMethod cm = CtNewMethod.make(cp.get(type), name,
 					asCtClassArray(parameters), exces, null, cc);
 			cm.setModifiers(cm.getModifiers() | Modifier.TRANSIENT);
 			return begin(cm);
 		} catch (CannotCompileException e) {
 			throw new ElmoCompositionException(e);
 		} catch (NotFoundException e) {
 			throw new ElmoCompositionException(e);
 		}
 	}
 
 	public CodeBuilder getCodeBuilder() {
 		return cb;
 	}
 
 	public CtClass getCtClass() {
 		return cc;
 	}
 
 	public Set<String> getDeclaredFieldNames() {
 		CtField[] fields = cc.getDeclaredFields();
 		Set<String> result = new HashSet<String>(fields.length);
 		for (CtField field : fields) {
 			result.add(field.getName());
 		}
 		return result;
 	}
 
 	public Class<?>[] getInterfaces() throws ElmoCompositionException {
 		try {
 			CtClass[] cc1 = cc.getInterfaces();
 			Class<?>[] result = new Class<?>[cc1.length];
 			for (int i = 0; i < cc1.length; i++) {
 				result[i] = cp.getJavaClass(cc1[i]);
 			}
 			return result;
 		} catch (NotFoundException e) {
 			throw new ElmoCompositionException(e);
 		} catch (ClassNotFoundException e) {
 			throw new ElmoCompositionException(e);
 		}
 	}
 
 	public CodeBuilder overrideMethod(Method method)
 			throws ElmoCompositionException {
 		return createMethod(method.getReturnType(), method.getName(), method
 				.getParameterTypes());
 	}
 
 	@Override
 	public String toString() {
 		return cc.getName();
 	}
 
 	private CtClass[] asCtClassArray(Class<?>[] cc) throws NotFoundException {
 		CtClass[] result = new CtClass[cc.length];
 		for (int i = 0; i < cc.length; i++) {
 			result[i] = cp.get(cc[i]);
 		}
 		return result;
 	}
 
 	private CodeBuilder begin(final CtMethod cm) {
 		CodeBuilder cb = new CodeBuilder(this, cp) {
 			@Override
 			public CodeBuilder end() {
 				code("}");
 				CtClass cc = cm.getDeclaringClass();
 				try {
 					int mod = cm.getModifiers();
 					mod = Modifier.clear(mod, Modifier.ABSTRACT);
 					mod = Modifier.clear(mod, Modifier.NATIVE);
 					cm.setModifiers(mod);
 					cm.setBody(toString());
 					try {
 						cc.getDeclaredMethod(cm.getName(), cm
 								.getParameterTypes());
 					} catch (NotFoundException e) {
 						cc.addMethod(cm);
 					}
 				} catch (Exception e) {
 					StringBuilder sb = new StringBuilder();
 					try {
 						for (CtClass inter : cc.getInterfaces()) {
 							sb.append(inter.getSimpleName()).append(" ");
 						}
 					} catch (NotFoundException e2) {
 					}
 					String sn = cc.getSimpleName();
 					System.err.println(sn + " implements " + sb);
 					throw new ElmoCompositionException(e.getMessage() + " for "
 							+ toString(), e);
 				}
 				clear();
 				return this;
 			}
 		};
 		return cb.code("{");
 	}
 
 }