//
   // $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/NeoHelper.java
   // $
   //
   
  package de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.impl;
  
  import java.util.Iterator;
  
  import org.eclipse.emf.ecore.EcorePackage;
  import org.neo4j.api.core.Direction;
  import org.neo4j.api.core.NeoService;
  import org.neo4j.api.core.Node;
  import org.neo4j.api.core.Relationship;
  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.dao.Constants;
  import de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.EcoreRelationshipType;
  
  /**
   * Helper class for DAO layer, specially for neo4j persistence.
   */
  public class NeoHelper
  {
    /** Neo4j service. */
    private NeoService neo;
  
    /**
     * Setter.
     * 
     * @param neoService
     *          Neo4j service
     */
    public void setNeo(final NeoService neoService)
    {
      neo = neoService;
    }
  
    /**
     * Getter.
     * 
     * @return Neo4j service
     */
    public NeoService getNeo()
    {
      return neo;
    }
  
    /**
     * Determine all information from a given node.
     *
     * @param node
     *          Node
     * @return Informations
     */
    public String toString(final Node node)
    {
      final StringBuilder buf = new StringBuilder("[").append(node.getId());
  
      for (final Relationship rel : node.getRelationships(Direction.OUTGOING))
      {
        buf.append("|").append(rel.getType().toString()).append("(").append(rel.getId()).append(")").append("->").append(
            rel.getEndNode().getId());
      }
      for (final String key : node.getPropertyKeys())
      {
        buf.append("|").append(key).append(":").append(node.getProperty(key));
      }
      return buf.append("]").toString();
    }
  
    /**
     * Determines the model node for the given namespace uri.
     *
     * @param nsUri
     *          the model's namespace uri
     * @return the model's node representation of <code>EPackage</code>
     */
    public Node getModelNode(final String nsUri)
    {
      // model node
      final Iterable<Node> models = getSubrefNodeChildren(EcoreRelationshipType.RESOURCES);
      for (final Node model : models)
      {
        if (model.getProperty(Constants.PROPERTY_NS_URI).equals(nsUri))
        {
          return model;
        }
      }
      return null;
    }
  
    /**
    * Create a subref node that is bound to the reference node by the specified
    * relationship type.
    *
    * @param relationshipType
    *          the relationship type
    * @return the subref node
    */
   private Node createSubrefNode(final EcoreRelationshipType relationshipType)
   {
     final Node subrefNode = neo.createNode();
     neo.getReferenceNode().createRelationshipTo(subrefNode, relationshipType);
     return subrefNode;
   }
 
   /**
    * Determines the one and only subref node bound to the reference node by the
    * specified relationship type.
    *
    * @param relationshipType
    *          the relationship type
    * @return the subref node
    */
   public Node getSubrefNode(final EcoreRelationshipType relationshipType)
   {
     final Node root = neo.getReferenceNode();
     final Iterator<Relationship> iter = root.getRelationships(relationshipType, Direction.OUTGOING).iterator();
     if (iter.hasNext())
     {
       return iter.next().getEndNode();
     }
     else
     {
       return createSubrefNode(relationshipType);
     }
   }
 
   /**
    * Determines the relationships from a subref node to its children.
    *
    * @param relationshipType
    *          the relationship type
    * @return Relationship Iterable
    */
   private Iterable<Relationship> getSubrefRelationships(
       final EcoreRelationshipType relationshipType)
   {
     return getSubrefNode(relationshipType).getRelationships(Direction.OUTGOING);
   }
 
   /**
    * Determines the children of the subrefNode bound to the reference node by
    * the specified relationship type.
    *
    * @param relationshipType
    *          the relationship type from reference node to subreference node.
    * @return subref node children Iterable
    */
   public Iterable<Node> getSubrefNodeChildren(final EcoreRelationshipType relationshipType)
   {
     return new Iterable<Node>()
     {
       /**
        * @see java.lang.Iterable#iterator()
        */
       @Override
       public Iterator<Node> iterator()
       {
         final Iterator<Relationship> iter = getSubrefRelationships(relationshipType).iterator();
 
         return new Iterator<Node>()
         {
           /**
            * @see java.util.Iterator#hasNext()
            */
           @Override
           public boolean hasNext()
           {
             return iter.hasNext();
           }
 
           /**
            * @see java.util.Iterator#next()
            */
           @Override
           public Node next()
           {
             return iter.next().getEndNode();
           }
 
           /**
            * @see java.util.Iterator#remove()
            */
           @Override
           public void remove()
           {
             throw new UnsupportedOperationException();
           }
         };
       }
     };
   }
 
   /**
    * Determine a node by a given name inside a model by a given nsURI.
    * 
    * @param elementName
    *          Element name
    * @return Node
    */
   public Node determineEcoreClassifierNode(final String elementName)
   {
     // find model
     final Node model = getModelNode(EcorePackage.eNS_URI);
     if (null == model)
     {
       return null;
     }
 
     // traverse from model to all classifiers
     for (final Node node : model.traverse(Order.BREADTH_FIRST, StopEvaluator.END_OF_GRAPH,
         ReturnableEvaluator.ALL_BUT_START_NODE, EcoreRelationshipType.CONTAINS, Direction.OUTGOING))
     {
       if (node.hasProperty(Constants.PROPERTY_NAME))
       {
         final String name = (String) node.getProperty(Constants.PROPERTY_NAME);
         if (name.equals(elementName))
         {
           return node;
         }
       }
     }
     return null;
   }
 }