package org.ocltf.translation;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.URL;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
   
  import javassist.CannotCompileException;
  import javassist.ClassPool;
  import javassist.CtClass;
  import javassist.CtField;
  import javassist.CtMethod;
  import javassist.LoaderClassPath;
  import javassist.NotFoundException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.ocltf.logging.Logger;
  import org.ocltf.utils.ExceptionUtils;
  import org.ocltf.utils.FileResourceUtils;
  
  /***
   * This class allows us to trace the parsing of the expression.
   * It is reflectively extended by Javaassist to allow the inclusion
   * of all "inA" and "outA" methods produced by the SableCC parser.  This allows
   * us to dynamically include all handling code in each method without having
   * to manual code each one.  It used used during development of Translators
   * since it allows you to see the execution of each node.
   * 
   * @author Chad Brandon   
   */
  public class TraceTranslator extends BaseTranslator {
      
  	private static final Log logger = LogFactory.getLog(TraceTranslator.class);
  
  	private static final String INA_PREFIX = "inA";
  	private static final String OUTA_PREFIX = "outA";
      
      private Map methods = new HashMap();
  	
  	/***
  	 * This is added to the adapted class and
  	 * then checked to see if it exists to determine
  	 * if we need to adapt the class.
  	 */
  	private static final String FIELD_ADAPTED = "adapted";
  
  	private ClassPool pool;
  	
  	/***
  	 * Constructs an instance of TraceTranslator.
  	 */
  	public TraceTranslator() {}
  
  	/***
  	 * Creates and returns an new Instance of this ExpressionTranslator 
  	 * as a Translator object. The first time this method is
  	 * called this class will dynamically be adapted to handle
  	 * all parser calls.  
  	 * 
  	 * @return Translator
  	 * @throws IllegalArgumentException - if the
  	 * 		    analysisSuperClass doesn't implement Analysis.
  	 */
  	public static Translator getInstance() {
  		String debugMethodName = "getInstance";
  		if (logger.isDebugEnabled()) {
  			logger.debug("performing " + debugMethodName);
  		}
  		try {
  			TraceTranslator oclTranslator = new TraceTranslator();
  			Translator translator = oclTranslator;
  			if (oclTranslator.needsAdaption()) {
  				
  				if (logger.isInfoEnabled()) {
  					logger.info(
  						" OCL Translator has not been adapted --> adapting");
  				}			
  				translator = (Translator)
  					oclTranslator.getAdaptedTranslationClass().newInstance();	
  			}
  			return translator;
  		} catch (Exception ex) {
  			String errMsg = "Error performing " + debugMethodName;
  			logger.error(errMsg, ex);
  			throw new TranslatorException(errMsg, ex);
  		}
  	}
      
  	/***
  	 * @see org.ocltf.translation.Translator#translate(java.lang.String, java.lang.Object, java.lang.String)
  	 */
      public Expression translate(String translationName, Object contextElement, String expression) {
          if (logger.isInfoEnabled()) {
              logger.info("======================== Tracing Expression ========================");
          	logger.info(TranslationUtils.removeExtraWhitespace(expression));
              logger.info("======================== ================== ========================");
         }
         Expression expressionObj = super.translate(translationName, contextElement, expression);
         if (logger.isInfoEnabled()) {
         	logger.info("========================  Tracing Complete  ========================");
         }
         return expressionObj;
     }
 
 	/***
 	 * Checks to see if this class needs to be adapated
 	 * If it has the "adapted" field then we know it already
 	 * has been adapted.
 	 * @return true/false, true if it needs be be adapted.
 	 */
 	protected boolean needsAdaption() {
 		boolean needsAdaption = false;
 		try {
 			this.getClass().getDeclaredField(FIELD_ADAPTED);
 		} catch (NoSuchFieldException ex) {
 			needsAdaption = true;
 		}
 		return needsAdaption;
 	}
 
 	/***
 	 * Creates and returns the adapted translator class.
      * @return Class the new Class instance.
 	 * @throws NotFoundException
 	 * @throws CannotCompileException
 	 * @throws IOException
 	 */
 	protected Class getAdaptedTranslationClass()
 		throws NotFoundException, CannotCompileException, IOException {
 
 		Class thisClass = this.getClass();
 		this.pool =
 			TranslatorClassPool.getPool(thisClass.getClassLoader());
 	
 		CtClass ctTranslatorClass = pool.get(thisClass.getName());
 
 		CtField adaptedField = new CtField(
 			CtClass.booleanType, 
 			FIELD_ADAPTED, 
 			ctTranslatorClass);
 			
 		ctTranslatorClass.addField(adaptedField);
 
 		//get the "inA" methods from the analysisClass
 		CtMethod[] analysisMethods = ctTranslatorClass.getMethods();
 
 		if (analysisMethods != null) {
             
 			int methodNum = analysisMethods.length;
             
 			for (int ctr = 0; ctr < methodNum; ctr++) {
 				CtMethod method = analysisMethods[ctr];
 				String methodName = method.getName();
 				
 				if (methodName.startsWith(INA_PREFIX)) {
 					//add the new overriden "inA" methods  
                     this.methods.put(method, getInAMethodBody(method));                        
 				} else if (methodName.startsWith(OUTA_PREFIX)) {
 					//add the new overriden "outA" methods
                     this.methods.put(method, getOutAMethodBody(method));
 				}
 			}
             
             //now add all the methods to the class
             Iterator allMethods = this.methods.keySet().iterator();
             while (allMethods.hasNext()) {
                 CtMethod method = (CtMethod)allMethods.next();
                 CtMethod newMethod =
                     new CtMethod(method, ctTranslatorClass, null);   
                 String methodBody = (String)this.methods.get(method);
                 newMethod.setBody(methodBody);    
                 ctTranslatorClass.addMethod(newMethod);
             }
 
 		}
 		this.writeAdaptedClass();
 		return ctTranslatorClass.toClass();
 	}
 
 	/***
 	 * Writes the class to the directory found by the class loader 
 	 * (since the class is a currently existing class)
 	 */
 	protected void writeAdaptedClass() {
 		String methodName = "writeAdaptedClass";
 		if (logger.isDebugEnabled()) {
 			logger.debug("performing " + methodName);
 		}
 		try {
 			String className = this.getClass().getName();
 			File dir = this.getAdaptedClassOutputDirectory();
 			if (logger.isDebugEnabled()) {
 				logger.debug("writing className (" 
 					+ className + ") to directory --> "
 					+ "(" + dir + ")");
 			}
 			this.pool.writeFile(
 				this.getClass().getName(), 
 				dir.toString());
 		} catch (Exception ex) {
 			String errMsg = "Error performing " + methodName;
 			logger.error(errMsg, ex);
 			throw new TranslatorException(errMsg, ex);
 		}
 	}
 	
 	/***
 	 * Retrieves the output directory which
 	 * the adapted class will be written to.
 	 * @return
 	 */
 	protected File getAdaptedClassOutputDirectory() {
 		String methodName = "getAdaptedClassOutputDirectory";
 		Class thisClass = this.getClass();
 		URL classAsResource = FileResourceUtils.getClassResource(thisClass);
 		File file = new File(classAsResource.getFile());
 		File dir = file.getParentFile();
 		if (dir == null) {
 			throw new TranslatorException(
 				methodName
 					+ " - can not retrieve directory for file ("
 					+ file
 					+ ")");
 		}		
 		String className = thisClass.getName();
 		int index = className.indexOf('.');
 		String basePackage = null;
 		if (index != -1) {
 			basePackage = className.substring(0, index);
 		}
 		if (basePackage != null) {
 			while (!dir.toString().endsWith(basePackage)) {
 				dir = dir.getParentFile();
 			}
 			dir = dir.getParentFile();
 		}
 		return dir;
 	}
 
 	/***
 	 * Creates and returns the method body for each "inA" method
 	 * @param method
 	 * @return String
 	 * @throws NotFoundException
 	 */
 	protected String getInAMethodBody(CtMethod method) throws NotFoundException {
 		String methodDebugName = "getInAMethodBody";
 		ExceptionUtils.checkNull(methodDebugName, "method", method);
 		StringBuffer methodBody = new StringBuffer("{");
 		String methodName = method.getName();
 		methodBody.append("String methodName = \"" + methodName + "\";");
 		methodBody.append(this.getMethodTrace(method));
 		//add the call of the super class method, so that any methods in sub classes
 		//can provide functionality
 		methodBody.append("super." + methodName + "($1);");
 		methodBody.append("}");
 		return methodBody.toString();
 	}
 	
 	/***
 	 * Creates and returns the method body for each "inA" method
 	 * @param method
 	 * @return String
 	 * @throws NotFoundException
 	 */
 	protected String getOutAMethodBody(CtMethod method) throws NotFoundException {
 		String methodDebugName = "getOutAMethodBody";
 		ExceptionUtils.checkNull(methodDebugName, "method", method);
 		StringBuffer methodBody = new StringBuffer("{");
 		String methodName = method.getName();
 		methodBody.append("String methodName = \"" + methodName + "\";");
 		methodBody.append(this.getMethodTrace(method));
 		//add the call of the super class method, so that any methods in sub classes
 		//can provide functionality
 		methodBody.append("super." + methodName + "($1);");
 		methodBody.append("}");
 		return methodBody.toString();
 	}
 
 	/***
 	 * Returns the OCL fragment name that must have
 	 * a matching name in the library translation template in order to
 	 * be placed into the Expression translated expression buffer.
 	 * @param method
 	 * @return String
 	 */
 	protected String getOclFragmentName(CtMethod method) {
 		String methodName = "getOclFragmentName";
 		ExceptionUtils.checkNull(methodName, "method", method);
 		String fragment = method.getName();
 		String prefix = this.getMethodPrefix(method);
 		int index = fragment.indexOf(prefix);
 		if (index != -1) {
 			fragment =
 				fragment.substring(index + prefix.length(), fragment.length());
 		}
 		return fragment;
 	}
 
 	/***
 	 * Returns the prefix for the method (inA or outA)
 	 * @param method
 	 * @return
 	 */
 	protected String getMethodPrefix(CtMethod method) {
 		String methodName = "getMethodPrefix";
 		ExceptionUtils.checkNull(methodName, "method", method);
 		String mName = method.getName();
 		String prefix = INA_PREFIX;
 		if (mName.startsWith(OUTA_PREFIX)) {
 			prefix = OUTA_PREFIX;
 		}
 		return prefix;
 	}
 
 	/***
 	 * Creates the debug statement that will be output for each method
 	 * @param method
 	 * @return
 	 * @throws NotFoundException
 	 */
 	protected String getMethodTrace(CtMethod method) throws NotFoundException {
 		String methodName = "getMethodDebug";
 		ExceptionUtils.checkNull(methodName, "method", method);
 		StringBuffer buf =
 			new StringBuffer("if (logger.isInfoEnabled()) {logger.info(\"");
 		buf.append("\" + methodName + \" with ");
 		//javaassist names the arguments $1,$2,$3, etc.
 		buf.append("'\" + org.ocltf.translation.TranslationUtils.trimToEmpty($1) + \"'\");}");
 		return buf.toString();
 	}
 
 	/***
 	 * Extends the Javaassist class pool so that we can 
 	 * define our own ClassLoader to use from which to find, load
 	 * and modify and existing class.
 	 * 
 	 * @author Chad Brandon
 	 */
 	protected static class TranslatorClassPool extends ClassPool {
 
 		private static Log logger =
 			LogFactory.getLog(TranslatorClassPool.class);
 
 		protected TranslatorClassPool() {
 			super(ClassPool.getDefault());
 			if (logger.isInfoEnabled()) {
 				logger.debug("instantiating new TranslatorClassPool");
 			}
 		}
 
 		/***
 		 * Retrieves an instance of this TranslatorClassPool
 		 * using the loader to find/load any classes.
 		 * @param loader
 		 * @return
 		 */
 		protected static ClassPool getPool(ClassLoader loader) {
 			if (loader == null) {
 				loader = Thread.currentThread().getContextClassLoader();
 			}
 			TranslatorClassPool pool = new TranslatorClassPool();
 			pool.insertClassPath(new LoaderClassPath(loader));
 			return pool;
 		}
 
 		/***
 		 * Returns a <code>java.lang.Class</code> object.
 		 * It calls <code>write()</code> to obtain a class file and then
 		 * loads the obtained class file into the JVM.  The returned
 		 * <code>Class</code> object represents the loaded class.
 		 *
 		 * <p>To load a class file, this method uses an internal class loader.
 		 * Thus, that class file is not loaded by the system class loader,
 		 * which should have loaded this <code>AspectClassPool</code> class.
 		 * The internal class loader
 		 * loads only the classes explicitly specified by this method
 		 * <code>writeAsClass()</code>.  The other classes are loaded
 		 * by the parent class loader (the sytem class loader) by delegation.
 		 * Thus, if a class <code>X</code> loaded by the internal class
 		 * loader refers to a class <code>Y</code>, then the class
 		 * <code>Y</code> is loaded by the parent class loader.
 		 *
 		 * @param classname         a fully-qualified class name.
 		 * @return Class the Class it writes.
 		 * @throws NotFoundException
 		 * @throws IOException
 		 * @throws CannotCompileException
 		 */
 		public Class writeAsClass(String classname)
 			throws NotFoundException, IOException, CannotCompileException {
 			try {
 				return classLoader.loadClass(classname, write(classname));
 			} catch (ClassFormatError e) {
 				throw new CannotCompileException(e, classname);
 			}
 		}
 
         /***
          * LocalClassLoader which allows us to dynamically construct
          * classes on the fly using Javassist.
          */
 		static class LocalClassLoader extends ClassLoader {
             /***
              * Constructs an instance of LocalClassLoader.
              * 
              * @param parent
              */
 			public LocalClassLoader(ClassLoader parent) {
 				super(parent);
 			}
             /***
              * Loads a class.
              * @param name the name
              * @param classfile the bytes of the class.
              * @return Class 
              * @throws ClassFormatError
              */
 			public Class loadClass(String name, byte[] classfile)
 				throws ClassFormatError {
 				Class c = defineClass(name, classfile, 0, classfile.length);
 				resolveClass(c);
 				return c;
 			}
 		};
 
 		/***
 		 * Create the LocalClassLoader and specify the ClassLoader for this class
 		 * as the parent ClassLoader.  This allows classes defined outside
 		 * this LocalClassLoader to be loaded (i.e. classes that already exist,
 		 * and aren't being dynamically created
 		 */
 		private static LocalClassLoader classLoader =
 			new LocalClassLoader(LocalClassLoader.class.getClassLoader());
 	}
 	
 	/***
 	 * This method is called by the main method 
 	 * during the build process, to "adapt"
 	 * the class to the OCL parser.
 	 */	
 	protected static void adaptClass() {
 		if (logger.isInfoEnabled()) {
 			logger.info("adapting class for OCL parser");
 		}
 		TraceTranslator translator = new TraceTranslator();
 		if (translator.needsAdaption()) {
 			try {
 				translator.getAdaptedTranslationClass();
 			} catch (Throwable th) {
 				logger.error(th);
 			}
 		}		
 	}
 	
 	/***
 	 * This main method is called during the build process, to "adapt"
 	 * the class to the OCL parser.
 	 * @param args
 	 */
 	public static void main(String args[]) {
         try {
     		Logger.configure();
     		TraceTranslator.adaptClass();
         } catch (Throwable th) {
         	logger.error(th);
         }
 	}
 
 }