package org.ocltf.translation.library;
   
   import java.io.BufferedReader;
   import java.io.Reader;
   import java.io.StringReader;
   import java.io.StringWriter;
   import java.lang.reflect.Method;
   import java.net.URL;
   import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.digester.xmlrules.DigesterLoader;
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.lang.builder.ToStringBuilder;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.ocltf.common.ComponentContainer;
  import org.ocltf.templateengine.TemplateEngine;
  import org.ocltf.translation.Translator;
  import org.ocltf.utils.ExceptionUtils;
  import org.ocltf.utils.XmlResourceUtils;
  
  /***
   * The LibraryTranslation object which stores
   * 
   * @author Chad Brandon
   */
  public class LibraryTranslation {
  
  	private static Log logger = LogFactory.getLog(LibraryTranslation.class);
  
  	private static final String CLASS_NAME = Translation.class.getName();
  	private static final String TRANSLATION_RULES_XML = CLASS_NAME + "-Rules";
  
  	/***
  	 * The parent library to which this LibraryTranslation belongs.
  	 */
  	private Library library;
  
  	private String name;
  
  	private String file;
  
  	/***
  	 * The TemplateEngine implementation to use, if is set, then this one
  	 * overrides the TemplateEngine definied on the library that this
  	 * LibraryTranslation belongs to.
  	 */
  	private String templateEngineClass;
  
  	/***
  	 * The Translator implementation to use. This is required.
  	 */
  	private String translatorClass;
  
  	/***
  	 * After processing by the CartridgeTemplate engine, will contain the
  	 * processed translation.
  	 */
  	private Translation translation;
  
  	/***
  	 * @return String
  	 */
  	public String getName() {
  		return name;
  	}
  
  	/***
       * Sets the name.
       * 
  	 * @param name
  	 */
  	public void setName(String name) {
  		this.name = name;
  	}
  
  	/***
  	 * @return String
  	 */
  	public String getFile() {
  		return file;
  	}
  
  	/***
  	 * @param file
  	 */
  	public void setFile(String file) {
  		this.file = file;
  	}
  
  	/***
  	 * Returns the Library that this LibraryTranslation
  	 * belongs too.
  	 * 
  	 * @return Library
  	 */
  	public Library getLibrary() {
  		return library;
 	}
 
 	/***
 	 * @param library
 	 */
 	public void setLibrary(Library library) {
 		this.library = library;
 	}
 
 	/***
 	 * Gets the TemplateEngine instance that will perform processing of the
 	 * file.
 	 * 
 	 * @return TemplateEngine
 	 */
 	public TemplateEngine getTemplateEngine() {
         return (TemplateEngine)ComponentContainer.instance().findComponent(
             templateEngineClass, TemplateEngine.class);
 	}
 
 	/***
 	 * Sets the TemplateEngine class that will perform processing of the file.
 	 * 
 	 * @param templateEngineClass
 	 */
 	public void setTemplateEngine(String templateEngineClass) {
 		this.templateEngineClass = templateEngineClass;
 	}
 
 	/***
 	 * Sets the Translator class that will perform the translation processing.
 	 * 
 	 * @param translatorClass
 	 */
 	public void setTranslator(String translatorClass) {
         this.translatorClass = translatorClass;
         ComponentContainer.instance().registerComponentType(translatorClass);
 	}
 
 	/***
 	 * Gets the Translator instance that will perform processing of the file.
 	 * 
 	 * @return Translator
 	 */  
 	public Translator getTranslator() {
         String methodName = "getTranslator";
         Translator translator = 
             (Translator)ComponentContainer.instance().findComponent(
                 this.translatorClass, Translator.class);
         if (translator == null) {
             throw new LibraryException(
                     methodName
                     + " - a translator implementation must be defined, "
                     + " please check your translator library --> "
                     + this.library.getResource());
         }
         return translator;
 	}
 
 	/***
 	 * Calls the handlerMethod from a translation fragment.  Each
      * handle method must take a java.lang.String as the first argument 
      * (the body of the fragment from the translation file) and a 
      * java.lang.Object for the second argument (the node being parsed that
      * we may need to retrieve any additional information from).
 	 * 
 	 * @param name the name of the fragment to retrieve.
 	 * @param node the node Object which from the parsed expression.
      * @param kind the kind of the translation fragment to handle.
 	 */
 	public void handleTranslationFragment(
 		String name,
         String kind,
 		Object node) {
 		String methodName = "handleTranslationFragment";
         ExceptionUtils.checkNull(methodName, "node", node);
 		if (this.translation != null && this.getTranslator() != null) {
             
             String translation = this.getTranslationFragment(name, kind);
             
             //only handle the fragment if we can find the fragment in the 
             //translation file
             if (StringUtils.isNotEmpty(translation)) {
             
     			String handlerMethod =
     				this.translation.getFragment(name).getHandlerMethod();
     			if (StringUtils.isNotEmpty(handlerMethod)) {
                     
                     Class[] argTypes = new Class[] {
                         java.lang.String.class, 
                         java.lang.Object.class
                     };                
                     
     				try {
         
     					Method method =
     						this.getTranslator().getClass().getMethod(
     							handlerMethod,
     							argTypes);               
                         
                         //add the translation as the first arg
                         Object[] args = new Object[] {
                             translation,
                         	node
                         };
                         
                         method.invoke(this.getTranslator(), args);
     				} catch (NoSuchMethodException ex) {
     					String errMsg =
     						"the translator '"
     							+ this.getTranslator().getClass()
     							+ "' must implement the method '"
     							+ handlerMethod
     							+ "("
     							+ StringUtils.join(argTypes, ",")
     							+ ")'"
     							+ " in order to handle processing of the fragment --> '"
     							+ name
     							+ "'";
     					logger.error(errMsg);
     				} catch (Exception ex) {
     					String errMsg = "Error performing " + methodName;
     					logger.error(errMsg, ex);
     					throw new LibraryException(errMsg, ex);
     				}
     			}
             }
 		}
 	}
 
 	/***
 	 * Gets the current "translated" value of this fragmentName for resulting
 	 * from the last processTranslation method
 	 * 
 	 * @param name the name of the fragment to retrieve.
      * @param kind the kind or type of fragment to retrieve 
      * (this is the based on the expression type: body, inv, post, pre, etc).
 	 * 
 	 * @return String the value of the translated fragment or null of one
 	 *         wasn't found with the specified name.
 	 */
 	public String getTranslationFragment(String name, String kind) {
 		String fragment = null;
 		if (this.translation != null) {
 			fragment = this.translation.getTranslated(name, kind);
 		}
 		return fragment;
 	}
 
 	/***
 	 * The processed translation template as a Reader.
 	 * 
 	 * @param translationInput
 	 */
 	protected void setTranslation(Reader translationInput) {
 		String methodName = "setTranslation";
 		ExceptionUtils.checkNull(
 			methodName,
 			"translationInput",
 			translationInput);
 		ClassLoader loader = Thread.currentThread().getContextClassLoader();
 		URL rulesXml = XmlResourceUtils.getResource(TRANSLATION_RULES_XML);
 		try {
 			this.translation =
 				(Translation) DigesterLoader.load(
 					rulesXml,
 					loader,
 					translationInput);
 			this.translation.setLibraryTranslation(this);
 		} catch (Exception ex) {
 			String errMsg = "Error performing " + methodName;
 			logger.error(errMsg, ex);
 			throw new LibraryException(errMsg, ex);
 		}
 	}
 
 	/***
 	 * Processes the file belonging to this LibraryTranslation.
 	 * 
 	 * @param templateObjects -
 	 *            any key/value pairs that should be passed to the
 	 *            TemplateEngine while processing the translation file.
 	 * 
 	 * @return Translation - the Translation created from the processing the
 	 *         translation file.
 	 */
 	public Translation processTranslation(Map templateObjects) {
 		String methodName = "processTranslation";
 		if (logger.isDebugEnabled()) {
 			logger.debug(
 				"processing translation file --> "
 					+ this.getFile()
 					+ " with templateObjects --> "
 					+ templateObjects);
 		}
 
 		if (templateObjects == null) {
 			templateObjects = new HashMap();
 		}
 
         templateObjects.putAll(this.getLibrary().getTemplateObjects());
 
 		try {
 			TemplateEngine engine = this.getTemplateEngine();
 
 			StringWriter output = new StringWriter();
 			engine.processTemplate(this.getFile(), templateObjects, output);
 			String outputString = output.toString();
 			BufferedReader input =
 				new BufferedReader(new StringReader(outputString));
 			if (logger.isDebugEnabled()) {
 				logger.debug("processed output --> " + outputString);
 			}
 			//load Reader into the translation
 			this.setTranslation(input);
 		} catch (Exception ex) {
 			String errMsg = "Error performing " + methodName;
 			logger.error(errMsg, ex);
 			throw new LibraryException(errMsg, ex);
 		}
 		return this.translation;
 	}
     
     /***
      * @see java.lang.Object#toString()
      */
 	public String toString() {
 		return ToStringBuilder.reflectionToString(this);
 	}
 
 }