/**
    * $Id: SpringResourceManagerImpl.java 79 2006-12-15 21:39:11Z maldito_orco $
    * $Revision: 79 $
    * $Date: 2006-12-15 18:39:11 -0300 (Fri, 15 Dec 2006) $
    *
    * =========================================================================
    *
    * Copyright 2005 Tubo
    *
   *  Licensed under the Apache License, Version 2.0 (the "License");
   *  you may not use this file except in compliance with the License.
   *  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   */
  package org.tubo.resource.springimpl;
  
  //log
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  //velocity
  import org.apache.velocity.VelocityContext;
  import org.apache.velocity.Template;
  import org.apache.velocity.exception.ResourceNotFoundException;
  import org.apache.velocity.exception.ParseErrorException;
  import org.apache.velocity.app.Velocity;
  //spring
  import org.springframework.beans.factory.BeanFactory;
  import org.springframework.beans.factory.BeanFactoryAware;
  import org.springframework.beans.factory.xml.XmlBeanFactory;
  import org.springframework.beans.BeansException;
  import org.springframework.core.io.ByteArrayResource;
  //tubo
  import org.tubo.configuration.def.*;
  import org.tubo.resource.Manager;
  import org.tubo.resource.flow.FlowExecutor;
  import org.tubo.resource.flow.FlowContext;
  import org.tubo.resource.baseimpl.BaseAbstractResourceManager;
  import org.tubo.exception.TuboResourceException;
  import org.tubo.exception.ExceptionManager;
  import org.tubo.exception.TuboException;
  import org.tubo.item.Item;
  import org.tubo.event.Event;
  import org.tubo.kernel.Kernel;
  //java-util
  import java.util.Map;
  import java.util.Iterator;
  import java.util.Properties;
  import java.util.HashMap;
  //java-io
  import java.io.StringWriter;
  
  /**
   *
   * Created: Dec 1, 2005 6:02:44 AM
   * Last Modification Date: $Date: 2006-12-15 18:39:11 -0300 (Fri, 15 Dec 2006) $
   *
   * @author maldito_orco (maldito_orco@users.sourceforge.net)
   * @version $Revision: 79 $
   */
  public class SpringResourceManagerImpl extends BaseAbstractResourceManager implements BeanFactoryAware {
      public static final String RCS_ID = "$Id: SpringResourceManagerImpl.java 79 2006-12-15 21:39:11Z maldito_orco $";
      private static Log log = LogFactory.getLog(SpringResourceManagerImpl.class);
  
      /** Template file for beans based on exceptions */
      public final static String BEAN_EXCEPTION_MANAGER_TEMPLATE = "META-INF/templates/exception-manager-template.vm";
  
      /** Template file for beans based on exceptions */
      public final static String BEAN_EXCEPTION_TEMPLATE = "META-INF/templates/exception-template.vm";
  
      /** Template file for beans based on consumers */
      public final static String BEAN_CONSUMER_TEMPLATE = "META-INF/templates/bean-consumer-template.vm";
  
      /** Template file for beans based on components */
      public final static String BEAN_COMPONENT_TEMPLATE = "META-INF/templates/bean-component-template.vm";
  
      /** Template file for beans based on flows */
      public final static String BEAN_DEFAULT_TEMPLATE = "META-INF/templates/bean-default-template.vm";
  
      /** Template file for beans based on flows */
      public final static String BEAN_FLOW_TEMPLATE = "META-INF/templates/bean-flow-template.vm";
  
      /** Header for every spring xml context file */
      public static final String SPRING_CONTEXT_HEADFILE =
              "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
                      "<!DOCTYPE beans PUBLIC \"-//SPRING//DTD BEAN//EN\" \"http://www.springframework.org/dtd/spring-beans.dtd\">";
  
      /** Kernel bean ID */
      public static final String SPRING_KERNEL_BEAN_ID = "kernel";
  
      /** ResourceManager bean ID */
      public static final String SPRING_RESOURCE_MANAGER_BEAN_ID = "resourceManager";
  
     /** Item bean ID */
     public static final String SPRING_ITEM_BEAN_ID = "item";
 
     /** Event bean ID */
     public static final String SPRING_EVENT_BEAN_ID = "event";
 
     /** FlowContext bean ID */
     public static final String SPRING_FLOW_CONTEXT_BEAN_ID = "flowContext";
 
     /** ExceptionManager bean ID */
     public static final String SPRING_EXCEPTION_MANAGER_BEAN_ID = "exceptionManager";
 
     /** FlowExecutor bean ID */
     public static final String SPRING_FLOW_EXECUTOR_BEAN_ID = "flowExecutor";
 
     /** Spring bean factory */
     private BeanFactory beanFactory;
 
 
     /**
      * Default constructor protected. Used by test cases.
      * Don't change. USED ONLY BY TEST CASES!
      * @throws TuboResourceException
      */
     protected SpringResourceManagerImpl() throws TuboException {
     }
 
     public BeanFactory getBeanFactory() {
         return beanFactory;
     }
 
     public void setBeanFactory(BeanFactory beanFactory) {
         this.beanFactory = beanFactory;
     }
 
 
     /**
      * <p>
      * Get kernel instance
      * </p>
      * @return kernel instance
      * @throws TuboException
      */
     public Kernel getKernel() throws TuboException {
         Kernel kernel = null;
         try {
             //
             // get Item via Spring
             kernel = (Kernel)beanFactory.getBean(SPRING_KERNEL_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get a KERNEL", e);
             //
             // throw
             throw new TuboResourceException("Error trying to get a Kernel",e);
         }
         //
         // return
         return kernel;
     }
 
 
     /**
      * <p>
      * Create a new Item instance
      * </p>
      * @return new Item instance
      * @throws TuboException
      */
     public Item getNewItem() throws TuboException {
         Item item = null;
         try {
             //
             // get Item via Spring
             item = (Item)beanFactory.getBean(SPRING_ITEM_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get an Item", e);
             //
             // throw
             throw new TuboResourceException("Error trying to get an Item",e);
         }
         //
         // return
         return item;
     }
 
     /**
      * <p>
      * Create a new Item instance
      * </p>
      * @return new Item instance
      * @throws TuboException
      */
     public Event getNewEvent() throws TuboException {
         Event event = null;
         try {
             //
             // get Event via Spring
             event = (Event)beanFactory.getBean(SPRING_EVENT_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get an Event", e);
             //
             // throw
             throw new TuboResourceException("Error trying to get an Event",e);
         }
         //
         // return
         return event;
     }
 
     /**
      * <p>
      * Create a new FlowContext instance
      * </p>
      * @return new FlowContext instance
      * @throws TuboException
      */
     public FlowContext getNewFlowContext() throws TuboException {
         FlowContext flowContext = null;
         try {
             //
             // get FlowContext via Spring
             flowContext = (FlowContext)beanFactory.getBean(SPRING_FLOW_CONTEXT_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get a FlowContext", e);
             //
             // throw
             throw new TuboResourceException("Error trying to get a FlowContext",e);
         }
         //
         // return
         return flowContext;
     }
 
     public ExceptionManager getExceptionManager() throws TuboException {
         ExceptionManager manager = null;
         try {
             //
             // get ExceptionManager via Spring
             manager = (ExceptionManager)beanFactory.getBean(SPRING_EXCEPTION_MANAGER_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get ExceptionManager", e);
             //
             // throw
             throw new TuboResourceException("Error trying to get ExceptionManager '"+SPRING_EXCEPTION_MANAGER_BEAN_ID+"'",e);
         }
         //
         // check if manager==null (I need to be sure of this ... this method can'tt return null!)
         if (manager == null) {
             //
             // log error
             log.error("Error when returning ExceptionManager, return null");
             //
             // throw
             throw new TuboResourceException("Error when returning ExceptionManager, return null");
         }
         //
         // return 
         return manager;
     }
 
     public FlowExecutor getFlowExecutor() throws TuboException {
         FlowExecutor manager = null;
         try {
             //
             // get FlowExecutor via Spring
             manager = (FlowExecutor)beanFactory.getBean(SPRING_FLOW_EXECUTOR_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get FlowExecutor", e);
             //
             // throw
             throw getExceptionManager().getException(1302,SPRING_FLOW_EXECUTOR_BEAN_ID,e);
         }
         return manager;
     }
 
     /**
      * get a bean manager from spring
      * @param id
      * @return
      */
     public Manager getManager(String id) throws TuboException {
         //
         // reconfig id to adapt to all Managers
         id = id+"Manager";
         //
         // get manager
         Manager manager = null;
         try {
             //
             // get manager via Spring
             manager = (Manager)beanFactory.getBean(id);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get Manager identified by '"+id+"'", e);
             //
             // throw
             throw getExceptionManager().getException(1303,id,e);
         }
         //
         // return
         return manager;
     }
 
 
 
 
     public static SpringResourceManagerImpl newInstance(Configuration config) {
         //
         // trace
         if (log.isTraceEnabled()) log.trace(".newInstance() - Enter");
         //
         // initialize velocity
         initVelocity();
         //
         // create Spring resource descriptor based on configuration
         String stringResource = null;
         try {
             stringResource = createSpringContext(config);
         } catch (TuboResourceException e) {
             throw new TuboResourceException("Tubo configuration can't be created",e);
         }
         //
         // create Bean Factory
         ByteArrayResource byteResource = new ByteArrayResource(stringResource.getBytes());
         BeanFactory beanFactory = new XmlBeanFactory(byteResource);
         //
         // get resource manager
         SpringResourceManagerImpl rm = null;
         try {
             //
             // get FlowExecutor via Spring
             rm = (SpringResourceManagerImpl)beanFactory.getBean(SPRING_RESOURCE_MANAGER_BEAN_ID);
         } catch (BeansException e) {
             //
             // log error
             log.error("Error trying to get ResourceManager", e);
             //
             // throw
             throw new TuboResourceException("Error trying to get Spring ResourceManager",e);
         }
         //
         // set configuration
         // TODO: can be inyected? 
         rm.setConfiguration(config);
         //
         // trace
         if (log.isTraceEnabled()) log.trace(".newInstance() - Leave");
         //
         //  return resource manager
         return rm;
     }
 
 
 
 
     /**
      *
      */
     private static void initVelocity() throws TuboResourceException {
         //
         // setup velocity
         //Velocity.init("velocity.properties"); TODO: ver de poder cargar estas propiedades desde un file
         Properties p = new Properties();
         p.setProperty("resource.loader", "class");
         p.setProperty("class.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
         try {
             Velocity.init(p);
         } catch (Exception e) {
             throw new TuboResourceException("Velocity can't be initialized",e);
         }
     }
 
     /**
      * Create a Spring Context (Spring configuration) based on Configuration object.
      * @param config Configuration
      * @return A String with Spring representation of Configuration object.
      */
     protected static String createSpringContext(Configuration config) throws TuboResourceException {
         //
         // create StringBuffer
         StringBuffer buffer = new StringBuffer();
         //
         // add string context head file
         buffer.append(SPRING_CONTEXT_HEADFILE);
         //
         // open tag beans
         buffer.append("<beans>");
         //
         // === Default configuration
         //
         // create ExceptionManager spring definition
         appendSpringDefaultConfiguration(buffer,config);
         //
         // === Exception Contexts
         //
         // create ExceptionManager spring definition
         appendSpringExceptionManagerDefinition(buffer);
         //
         // === Flow Contexts
         //
         // create Flows spring definitions
         appendSpringFlowDefinition(buffer,config);
         //
         // get consumer defs
         Map exceptionMap = config.getExceptionDefs();
         //
         // iterate exception Defs and append definitions to spring context
         for (Iterator it=exceptionMap.values().iterator(); it.hasNext();) {
             ExceptionDef def = (ExceptionDef)it.next();
             //
             // create Exception spring definition
             buffer = appendSpringDefinition(buffer,def);
         }
         //
         // === Consumer Contexts
         //
         // get consumer defs
         Map consumersMap = config.getConsumerDefs();
         //
         // iterate consumer Defs and append definitions to spring context
         for (Iterator it=consumersMap.values().iterator(); it.hasNext();) {
             ConsumerDef def = (ConsumerDef)it.next();
             //
             // create spring definition
             buffer = appendSpringDefinition(buffer,def);
         }
         //
         // === Component Contexts
         //
         // get component Defs
         Map componentsMap = config.getComponentDefs();
         //
         // iterate component Defs and append definitions to spring context
         for (Iterator it=componentsMap.values().iterator(); it.hasNext();) {
             ComponentDef def = (ComponentDef)it.next();
             //
             // create spring definition
             buffer = appendSpringDefinition(buffer,def);
         }
         //
         // close tag beans
         buffer.append("</beans>");
         //
         // return Spring Resource
         return buffer.toString();
     }
 
     protected static StringBuffer appendSpringDefaultConfiguration(StringBuffer buffer, Configuration config) throws TuboResourceException {
         //
         // create Velocity props
         Map props = new HashMap();
         props.put("config",config);
         //
         // create spring definition (using Velocity)
         buffer = appendSpringDefinition(buffer,null,BEAN_DEFAULT_TEMPLATE,props);
         return buffer;
     }
 
     protected static StringBuffer appendSpringFlowDefinition(StringBuffer buffer, Configuration config) throws TuboResourceException {
         //
         // create Velocity props
         Map props = new HashMap();
         props.put("config",config);
         //
         // create spring definition (using Velocity)
         buffer = appendSpringDefinition(buffer,null,BEAN_FLOW_TEMPLATE,props);
         return buffer;
     }
 
     protected static StringBuffer appendSpringExceptionManagerDefinition(StringBuffer buffer) throws TuboResourceException {
         //
         // create Velocity props
         Map props = new HashMap();
         props.put("id",BEAN_EXCEPTION_MANAGER_TEMPLATE);
         //
         // create spring definition (using Velocity)
         buffer = appendSpringDefinition(buffer,null,BEAN_EXCEPTION_MANAGER_TEMPLATE,props);
         return buffer;
     }
 
     protected static StringBuffer appendSpringDefinition(StringBuffer buffer, Definition def) throws TuboResourceException {
         if (def instanceof ExceptionDef) {
             buffer = appendSpringDefinition(buffer,def,BEAN_EXCEPTION_TEMPLATE,null);
             return buffer;
         }
         if (def instanceof ConsumerDef) {
             buffer = appendSpringDefinition(buffer,def,BEAN_CONSUMER_TEMPLATE,null);
             return buffer;
         }
         if (def instanceof ComponentDef) {
             buffer = appendSpringDefinition(buffer,def,BEAN_COMPONENT_TEMPLATE,null);
             return buffer;
         }
         throw new TuboResourceException("Definition type not know.");
     }
 
     /**
      * Append a Spring configuration of ComponentDef instance.
      * @param buffer Spring configuration
      * @param def A ComponentDef instance
      * @return The same StringBuffer but with a new component (bean) definition append to end;
      */
     protected static StringBuffer appendSpringDefinition(StringBuffer buffer, Definition def, String templateFile, Map props) throws TuboResourceException {
         try {
             //
             // Make a context object and populate with the data.  This
             // is where the Velocity engine gets the data to resolve the
             // references (ex. $list) in the template
             VelocityContext context = new VelocityContext();
             context.put("def", def);
             //
             // add props to Velocity context
             if (props!=null)
                 for(Iterator it=props.keySet().iterator(); it.hasNext();) {
                     String key = (String)it.next();
                     Object value = props.get(key);
                     context.put(key,value);
                 }
             //
             // get the Template object.  This is the parsed version of your
             // template input file.  Note that getTemplate() can throw
             // ResourceNotFoundException : if it doesn't find the template
             // ParseErrorException : if there is something wrong with the VTL
             // Exception : if something else goes wrong (this is generally
             // indicative of as serious problem...)
             Template template =  null;
             try {
                 template = Velocity.getTemplate(templateFile);
             } catch( ResourceNotFoundException rnfe ) {
                 throw new TuboResourceException("Velocity template "+templateFile+" can't be founded",rnfe);
             } catch( ParseErrorException pee ) {
                 throw new TuboResourceException("Velocity parsing error procesing template "+templateFile,pee);
             }
             //
             // Now have the template engine process your template using the
             // data placed into the context.  Think of it as a  'merge'
             // of the template and the data to produce the output stream.
             StringWriter writer = new StringWriter();
             if ( template != null)
                 template.merge(context, writer);
             //
             //  flush and cleanup
             writer.flush();
             writer.close();
 
             buffer.append(writer.toString());
         } catch (Exception e) {
             throw new TuboResourceException("Error creating spring definition",e);
         }
         return buffer;
     }
 
 }