/*
    * Copyright 2010 Fraunhofer Gesellschaft, Munich, Germany,
    * for its Fraunhofer Institute for Computer Architecture and Software
    * Technology (FIRST), Berlin, Germany. All rights reserved.
    * http://www.first.fraunhofer.de/
    */
   
   package net.kwfgrid.gwes;
   
  import org.apache.log4j.Logger;
  import org.jdom.Element;
  import org.jdom.Content;
  import org.jdom.Document;
  import org.jaxen.SimpleNamespaceContext;
  import org.jaxen.JaxenException;
  import org.jaxen.XPath;
  import org.jaxen.jdom.JDOMXPath;
  import net.kwfgrid.gworkflowdl.structure.*;
  import net.kwfgrid.gwes.util.StringUtils;
  
  import java.util.List;
  import java.io.IOException;
  
  /**
   * This class evaluates XPath expressions and generates tokens based on the evaluation result.
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: TokenProcessor.java 1433 2010-11-29 18:06:07Z hoheisel $
   */
  public class TokenProcessor {
  
      private final static Logger logger = Logger.getLogger(TokenProcessor.class);
  
      private final Document context;
  
      private final TokenParameterList tokenList;
  
      private final SimpleNamespaceContext nsContext;
  
      /**
       * Constructor of the data token processor.
       * @param context The xml which is used as context for the evaluation.
       * @param tokenList A list of token parameters. 
       * @throws WorkflowFormatException
       */
      public TokenProcessor(SimpleNamespaceContext nsContext, Document context, TokenParameterList tokenList) {
          this.context = context;
          this.tokenList = tokenList;
          this.nsContext = nsContext;
          if (logger.isDebugEnabled()) {
              try {
                  logger.debug("context:\n"+JdomString.document2string(context));
              } catch (IOException e) {
                  logger.error("exception: " + e, e);
              }
          }
      }
  
      /**
       * Generate the data output tokens by evaluating the XPath expressions against the context.
       * This method only creates new tokens if the current token is null and if the XPath expression evaluation
       * returns a non-empty value.
       * @param props The generic properties to be included for all tokens.
       * @return The Token Map.
       * @throws WorkflowFormatException
       */
      public TokenParameterList generateOutputTokens(GenericProperties props) throws WorkflowFormatException {
          if (tokenList == null) return null;
          for (TokenParameter tp : tokenList) {
              // only generate new token if there is no old token.
              if (tp.token != null) continue;
              switch(tp.scope) {
                  case OUTPUT:
                      String xpathExpression = StringUtils.expandContextVariables(StringUtils.stripOwl(tp.edge.getExpression()));
                      if (xpathExpression == null) continue;
                      try {
                          Object obj = evaluate(xpathExpression);
                          Element tokenElement = new Element("data");
                          if (obj == null) {
                              // do nothing
                          } else if (obj instanceof List) {
                              List tokenElements = ((List) obj);
                              // create also data token, if list is empty
                              for (Object elementobj : tokenElements) {
                                  Content content = (Content) ((Content) elementobj).clone();
                                  tokenElement.addContent(content);
                              }
                          } else if (obj instanceof Double) {
                              Element element = new Element("double");
                              element.addContent(obj.toString());
                              tokenElement.addContent(element);
                          } else if (obj instanceof Boolean) {
                              Element element = new Element("boolean");
                              element.addContent(obj.toString());
                              tokenElement.addContent(element);
                          } else if (obj instanceof String) {
                              Element element = new Element("string");
                              element.addContent(obj.toString());
                              tokenElement.addContent(element);
                         } else {
                             throw new WorkflowFormatException("Type of evaluation result ["+obj.toString()+"] of edgeExpression '" + xpathExpression + "' is not supported");
                         }
                         Data data = Factory.newData(tokenElement);
                         tp.token = Factory.newToken(data,props);
                     } catch (JaxenException e) {
                         logger.error("exception: " + e, e);
                         throw new WorkflowFormatException("Could not interpret edgeExpression '" + xpathExpression + "' as XPath expression: " +e, e);
                     }
 
                     break;
             }
         }
 
         return tokenList;
     }
 
     /**
      * This method evaluates one XPath expression.
      * @param xpathExpression The XPath expression to evaluate.
      * @return The evaluation object.
      * @throws JaxenException
      */
     private Object evaluate(String xpathExpression) throws JaxenException {
         // xpath evaluation
         XPath xpath = new JDOMXPath(xpathExpression);
         xpath.setNamespaceContext(nsContext);
         Object ret = xpath.evaluate(context);
         if (logger.isDebugEnabled()) {
             logger.debug("Evaluation of expression '" + xpathExpression + "' returns " + ret.toString());
         }
         return ret;
     }
 
 }