// BSD License (http://www.galagosearch.org/license)
   package org.galagosearch.core.retrieval.structured;
   
   import java.lang.reflect.Array;
   import java.lang.reflect.Constructor;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import org.galagosearch.core.retrieval.query.Node;
  import org.galagosearch.core.retrieval.query.NodeType;
  import org.galagosearch.core.scoring.DirichletScorer;
  import org.galagosearch.tupleflow.Parameters;
  
  /***
   *
   * @author trevor
   */
  public class FeatureFactory {
      static String[][] sOperatorLookup = {
          {FilteredCombinationIterator.class.getName(), "filter"},
          {UnfilteredCombinationIterator.class.getName(), "combine"},
          {SynonymIterator.class.getName(), "syn"},
          {SynonymIterator.class.getName(), "synonym"},
          {ExtentInsideIterator.class.getName(), "inside"},
          {OrderedWindowIterator.class.getName(), "ordered"},
          {OrderedWindowIterator.class.getName(), "od"},
          {UnorderedWindowIterator.class.getName(), "unordered"},
          {UnorderedWindowIterator.class.getName(), "uw"},
          {ScaleIterator.class.getName(), "scale"}
      };
      static String[][] sFeatureLookup = {
          {DirichletScorer.class.getName(), "dirichlet"}
      };
      HashMap<String, String> featureLookup;
      HashMap<String, String> operatorLookup;
      Parameters parameters;
  
      public FeatureFactory(Parameters parameters) {
          operatorLookup = new HashMap<String, String>();
          featureLookup = new HashMap<String, String>();
          this.parameters = parameters;
          
          for (String[] item : sFeatureLookup) {
              featureLookup.put(item[1], item[0]);
          }
  
          for (String[] item : sOperatorLookup) {
              operatorLookup.put(item[1], item[0]);
          }
      }
  
      public String getClassName(Node node) throws Exception {
          String operator = node.getOperator();
  
          if (operator.equals("feature")) {
              return getFeatureClassName(node.getParameters());
          }
          String className = operatorLookup.get(operator);
  
          if (className == null) {
              throw new IllegalArgumentException(
                      "Unknown operator name: #" + operator);
          }
          return className;
      }
  
      public String getFeatureClassName(Parameters parameters) throws Exception {
          if (parameters.containsKey("class")) {
              return parameters.get("class");
          }
  
          String name = parameters.get("name", parameters.get("default", (String) null));
  
          if (name == null) {
              throw new Exception(
                      "Didn't find 'class', 'name', or 'default' parameter in this feature description.");
          }
  
          String className = featureLookup.get(name);
  
          if (className == null) {
              throw new Exception("Couldn't find a class for the feature named " + name + ".");
          }
  
          return className;
      }
  
      @SuppressWarnings("unchecked")
      public Class<StructuredIterator> getClass(Node node) throws Exception {
          String className = getClassName(node);
          Class c = Class.forName(className);
  
          if (StructuredIterator.class.isAssignableFrom(c)) {
              return (Class<StructuredIterator>) c;
          } else {
              throw new Exception("Found a class, but it's not a DocumentDataIterator: " + className);
          }
      }
      
     public NodeType getNodeType(Node node) throws Exception {
         return new NodeType(getClass(node));
     }
 
     boolean isUsableConstructor(
             Class[] types,
             ArrayList<StructuredIterator> childIterators) {
         // We require at least one parameter in a usable constructor.
         if (types.length == 0)
             return false;
             
         // The first parameter needs to be a parameters object.
         if (!Parameters.class.isAssignableFrom(types[0]))
             return false;
             
         // Only the last parameter can be an array
         for (int i = 0; i < types.length-1; ++i) {
             if (types[i].isArray())
                 return false;
         }
         
         boolean lastIsArray = types[types.length-1].isArray();
         
         // Does it have an appropriate number of arguments?
         int iteratorArgs = 1 + childIterators.size();
         // If the last argument isn't an array, the argument list length
         // needs to match exactly.
         if (iteratorArgs != types.length && !lastIsArray)
             return false;
         // If the last argument is an array, we need to have enough arguments to
         // satisfy everything but the array parameter (since it's okay to put
         // zero things in an array).
         if (lastIsArray && iteratorArgs < types.length-1)
             return false;
         
         // We now know it has the right number of args, so we check
         // the iterator parameters to make sure they match.
         int iteratorIndex = 0;
         int typeIndex;
         
         for (typeIndex = 1; typeIndex < types.length; typeIndex++) {
             Class currentType = types[typeIndex];
             if (currentType.isArray()) {
                 // we'll check all the rest of the child iterators here
                 for (; iteratorIndex < childIterators.size(); ++iteratorIndex) {
                    StructuredIterator iterator = childIterators.get(iteratorIndex);
                    if (!currentType.isAssignableFrom(iterator.getClass())) {
                        return false;
                    }
                 }
             } else {
                 if (iteratorIndex >= childIterators.size())
                     return false;
 
                 StructuredIterator iterator = childIterators.get(iteratorIndex);
                 if (!currentType.isAssignableFrom(iterator.getClass()))
                     return false;
             }
         }
 
         return true;
     }
     
     Object[] argsForConstructor(Class[] types,
             Parameters parameters,
             ArrayList<StructuredIterator> childIterators) {
         assert types.length > 0;
         
         Object[] args = new Object[types.length];
         // The first argument is a parameters object.
         args[0] = parameters;
         
         // The remaining arguments come from childIterators.
         for (int i = 1; i < args.length; ++i) {
             args[i] = childIterators.get(i-1);
         }
 
         // If the last argument is an array, we need to convert any remaining
         // childIterators to an array form.
         Class lastType = types[types.length-1];
         if (lastType.isArray()) {
             List<StructuredIterator> remaining =
                 childIterators.subList(types.length-2, childIterators.size());
             Object typedArray = Array.newInstance(lastType.getComponentType(), 0);
             Object[] remainingArray = remaining.toArray((Object[]) typedArray);
             args[args.length-1] = remainingArray;
         }
         
         return args;
     }
     
     /***
      * Given a query node, generates the corresponding iterator object that can be used
      * for structured retrieval.  This method just calls getClass() on the node,
      * then instantiates the resulting class.
      * 
      * If the class returned by getClass() is a ScoringFunction, it must contain
      * a constructor that takes a single Parameters object.  If the class returned by 
      * getFeatureClass() is some kind of StructuredIterator (either a ScoreIterator,
      * ExtentIterator or CountIterator), it must take a Parameters object and an
      * ArrayList of DocumentDataIterators as parameters.
      */
     public StructuredIterator getIterator(Node node, ArrayList<StructuredIterator> childIterators) throws Exception {
         NodeType type = getNodeType(node);
         
         Constructor constructor = type.getConstructor();
         Class[] types = type.getParameterTypes(1 + childIterators.size());
             
         if (!isUsableConstructor(types, childIterators)) {
             throw new Exception("Couldn't find a reasonable constructor.");
         }
         
         Parameters parametersCopy = new Parameters();
         parametersCopy.copy(node.getParameters());
         Object[] args = argsForConstructor(constructor.getParameterTypes(),
                                            parametersCopy,
                                            childIterators);
         RequiredStatistics required =
             type.getIteratorClass().getAnnotation(RequiredStatistics.class);
         if (required != null) {
             for (String statistic : required.statistics()) {
                 parametersCopy.add(statistic, parameters.get(statistic, null));
             }
         }
         return (StructuredIterator) constructor.newInstance(args);
     }
 }