//
   // $Revision: 5 $
   // $LastChangedBy: mhanns $
   // $Date: 2010-04-01 10:10:45 +0200 (Do, 01 Apr 2010) $
   // $HeadURL:
   // svn://localhost/winf-ps/trunk/repository/src/main/java/de/uni_leipzig/wifa/iwi/mr3/dao/impl/neo4j/SearchProcessor.java
   // $
   //
   
  package de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.impl;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import org.eclipse.emf.ecore.EcorePackage;
  import org.neo4j.api.core.Direction;
  import org.neo4j.api.core.Node;
  import org.neo4j.api.core.ReturnableEvaluator;
  import org.neo4j.api.core.StopEvaluator;
  import org.neo4j.api.core.Traverser.Order;
  
  import de.uni_leipzig.wifa.iwi.mr3.common.Match;
  import de.uni_leipzig.wifa.iwi.mr3.common.Segment;
  import de.uni_leipzig.wifa.iwi.mr3.dao.Constants;
  import de.uni_leipzig.wifa.iwi.mr3.dao.SearchProcessor;
  import de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.EcoreRelationshipType;
  
  /**
   * Search processor.
   */
  public class SearchProcessorImpl implements SearchProcessor
  {
    /** Neo4j helper. */
    private NeoHelper helper;
  
    /**
     * Setter.
     * 
     * @param helper
     *          the helper to set
     */
    public void setHelper(final NeoHelper helper)
    {
      this.helper = helper;
    }
  
    /**
     * Processes a complete search over all direct and indirect instances of
     * EObject.
     *
     * @param expression
     *          Search expresion
     * @param classifiers
     *          Classifiers to search for
     * @param isCaseSensitive
     *          Case sensitive search
     * @param isRegEx
     *          Regular expression search
     * @return array with found models
     * @see de.uni_leipzig.wifa.iwi.mr3.dao.SearchProcessor#processCompleteSearch(java.lang.String,
     *      java.lang.String[], boolean, boolean)
     */
    @Override
    public Match[] processCompleteSearch(
        final String expression,
        final String[] classifiers,
        final boolean isCaseSensitive,
        final boolean isRegEx)
    {
      final List<Node> registry = new ArrayList<Node>();
      final List<Match> matches = new ArrayList<Match>();
  
      final SearchReturnableEvaluator searchEvaluator = new SearchReturnableEvaluator(expression, isCaseSensitive, isRegEx);
      for (final Node model : helper.getSubrefNodeChildren(EcoreRelationshipType.RESOURCES))
      {
        for (final Node target : model.traverse(Order.DEPTH_FIRST, StopEvaluator.END_OF_GRAPH, searchEvaluator,
            EcoreRelationshipType.CONTAINS, Direction.OUTGOING, EcoreRelationshipType.REFERENCES_AS_CONTAINMENT,
            Direction.OUTGOING))
        {
          // jetzt haben wir alle gesuchten Nodes
          buildTreePath(target, searchEvaluator.getMatchedValues(), registry, matches);
        }
      }
      return matches.toArray(new Match[matches.size()]);
    }
  
    /**
     * Processes a partial search for instances of given classifiers.
     *
     * @param expression
     *          Search expresion
     * @param classifiers
     *          Classifiers to search for
     * @param isCaseSensitive
     *          Case sensitive search
     * @param isRegEx
     *          Regular expression search
     * @return array with found models
     * @see de.uni_leipzig.wifa.iwi.mr3.dao.SearchProcessor#processPartialSearch(java.lang.String,
    *      java.lang.String[], boolean, boolean)
    */
   @Override
   public Match[] processPartialSearch(
       final String expression,
       final String[] classifiers,
       final boolean isCaseSensitive,
       final boolean isRegEx)
   {
     final List<Node> registry = new ArrayList<Node>();
     final List<Match> matches = new ArrayList<Match>();
 
     final SearchReturnableEvaluator searchEvaluator = new SearchReturnableEvaluator(expression, isCaseSensitive, isRegEx);
 
     final Node ecore = helper.getModelNode(EcorePackage.eNS_URI);
     for (final Node metaClass : ecore.traverse(Order.BREADTH_FIRST, StopEvaluator.DEPTH_ONE,
         new ClassifiersReturnableEvaluator(classifiers), EcoreRelationshipType.CONTAINS, Direction.OUTGOING))
     {
       for (final Node eachMetaClass : metaClass.traverse(Order.DEPTH_FIRST, StopEvaluator.END_OF_GRAPH,
           ReturnableEvaluator.ALL, EcoreRelationshipType.SUPER, Direction.INCOMING))
       {
         for (final Node target : eachMetaClass.traverse(Order.BREADTH_FIRST, StopEvaluator.DEPTH_ONE, searchEvaluator,
             EcoreRelationshipType.INSTANCE, Direction.OUTGOING))
         {
           // jetzt haben wir alle gesuchten Nodes
           buildTreePath(target, searchEvaluator.getMatchedValues(), registry, matches);
         }
       }
     }
     return matches.toArray(new Match[matches.size()]);
   }
 
   /**
    * Adds a tree path of a found model element to the tree paths array of this
    * search processor.
    * @param target
    *          the node of the found model element
    * @param matchedValues
    *          the value of the found property
    * @param registry
    *          Node cache
    * @param treePaths
    *          Result container
    */
   private void buildTreePath(
       final Node target,
       final String[] matchedValues,
       final List<Node> registry,
       final List<Match> treePaths)
   {
     if (registry.contains(target))
     {
       return;
     }
     registry.add(target);
 
     for (final String value : matchedValues)
     {
       final Match match = new Match();
 
       if (!(target.hasProperty(Constants.PROPERTY_NAME) && value.equalsIgnoreCase((String) target
           .getProperty(Constants.PROPERTY_NAME))))
       {
         final Segment matchedValue = new Segment();
         matchedValue.setValue(value);
 
         match.addSegment(matchedValue);
       }
 
       for (final Node pathSegment : target.traverse(Order.DEPTH_FIRST, StopEvaluator.END_OF_GRAPH, ReturnableEvaluator.ALL,
           EcoreRelationshipType.CONTAINS, Direction.INCOMING, EcoreRelationshipType.REFERENCES_AS_CONTAINMENT,
           Direction.INCOMING))
       {
         final Segment segment = new Segment();
 
         final Node pathSegmentType =
             pathSegment.hasRelationship(EcoreRelationshipType.INSTANCE, Direction.INCOMING) ? pathSegment
                 .getSingleRelationship(EcoreRelationshipType.INSTANCE, Direction.INCOMING).getStartNode() : null;
         segment.setType(getQualifiedName(pathSegmentType));
         if (!pathSegment.hasRelationship(EcoreRelationshipType.CONTAINS, Direction.INCOMING)
             && pathSegment.hasProperty(Constants.PROPERTY_NS_URI))
         {
           // if this segment is the model, set the nsUri as segment name
           segment.setName((String) pathSegment.getProperty(Constants.PROPERTY_NS_URI));
         }
         else if (pathSegment.hasProperty(Constants.PROPERTY_NAME))
         {
           // if this segment has the name property, set its value as segment
           // name
           segment.setName((String) pathSegment.getProperty(Constants.PROPERTY_NAME));
           // EClass from the ecore package is a special case
           if (segment.getName().equals(EcorePackage.Literals.ECLASS.getName()))
           {
             segment.setType(EcorePackage.eNS_URI + "#//" + EcorePackage.Literals.ECLASS.getName());
           }
 
         }
         match.addSegment(segment);
       }
       treePaths.add(match);
     }
   }
 
   /**
    * Determines a qualified name of the given (type) node.
    *
    * @param pathSegmentType
    *          the node
    * @return Qualified name
    *         <p>
    */
   private String getQualifiedName(final Node pathSegmentType)
   {
     if (null == pathSegmentType)
     {
       return EcorePackage.eNS_URI + "#//" + EcorePackage.Literals.EOBJECT.getName();
     }
     final StringBuilder qualifiedName = new StringBuilder();
     for (final Node containerPackage : pathSegmentType.traverse(Order.DEPTH_FIRST, StopEvaluator.END_OF_GRAPH,
         ReturnableEvaluator.ALL, EcoreRelationshipType.CONTAINS, Direction.INCOMING))
     {
       if (containerPackage.hasProperty(Constants.PROPERTY_NS_URI))
       {
         qualifiedName.append((String) containerPackage.getProperty(Constants.PROPERTY_NS_URI));
         break;
       }
     }
     qualifiedName.append("#//").append(pathSegmentType.getProperty(Constants.PROPERTY_NAME));
     return qualifiedName.toString();
   }
 }