//
   // $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/ModelRepositoryDaoNeo4jImpl.java
   // $
   //
   
  package de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.impl;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.eclipse.emf.common.util.URI;
  import org.eclipse.emf.ecore.EObject;
  import org.eclipse.emf.ecore.EPackage;
  import org.eclipse.emf.ecore.EcorePackage;
  import org.eclipse.emf.ecore.resource.Resource;
  import org.eclipse.emf.ecore.resource.ResourceSet;
  import org.eclipse.emf.ecore.resource.Resource.Factory;
  import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
  import org.eclipse.emf.ecore.xmi.XMIResource;
  import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
  import org.neo4j.api.core.Direction;
  import org.neo4j.api.core.EmbeddedNeo;
  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.Transaction;
  import org.neo4j.api.core.Traverser.Order;
  
  import de.uni_leipzig.wifa.iwi.mr3.common.Match;
  import de.uni_leipzig.wifa.iwi.mr3.dao.Constants;
  import de.uni_leipzig.wifa.iwi.mr3.dao.LoadProcessor;
  import de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao;
  import de.uni_leipzig.wifa.iwi.mr3.dao.SaveProcessor;
  import de.uni_leipzig.wifa.iwi.mr3.dao.SearchProcessor;
  import de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.EcoreRelationshipType;
  import de.uni_leipzig.wifa.iwi.mr3.service.MRException;
  
  /**
   * Implementation of DAO for access to neo4j network database.
   */
  public class ModelRepositoryDaoNeo4jImpl implements ModelRepositoryDao
  {
    /** Logger. */
    private static final Logger LOG = Logger.getLogger(ModelRepositoryDaoNeo4jImpl.class);
  
    /** Neo instance. */
    private NeoService neo;
  
    /** Neo4j database path. */
    private String databasePath;
  
    /** Neo4j helper. */
    private NeoHelper helper;
  
    /** Search processor. */
    private SearchProcessor searchProcessor;
  
    /** Load processor. */
    private LoadProcessor loadProcessor;
  
    /** Save processor for phase one. */
    private SaveProcessor saveProcessorPhaseOne;
  
    /** Save processor for phase two. */
    private SaveProcessor saveProcessorPhaseTwo;
  
    /** Default content type literal. */
    private static final String DEFAULT_CONTENT_TYPE = "*";
  
    /** XMI resource factory. */
    private static final Factory RESOURCE_FACTORY = new XMIResourceFactoryImpl();
  
    /**
     * Setter.
     *
     * @param databasePath
     *          the databasePath to set
     */
    public void setDatabasePath(final String databasePath)
    {
      this.databasePath = databasePath;
    }
  
    /**
     * Getter.
     *
     * @return the databasePath
     */
   public String getDatabasePath()
   {
     return databasePath;
   }
 
   /**
    * Init the neo node space.
    */
   @Override
   public void startUp()
   {
     LOG.debug("Initialize database.");
     if (neo != null)
     {
       shutDown();
     }
     if (LOG.isInfoEnabled())
     {
       LOG.info("Using neo4j database location at " + new File(databasePath).getAbsolutePath());
     }
     neo = new EmbeddedNeo(databasePath);
 
     helper = new NeoHelper();
     helper.setNeo(neo);
 
     final PhaseOneSaveProcessor spp1 = new PhaseOneSaveProcessor();
     spp1.setHelper(helper);
     saveProcessorPhaseOne = spp1;
 
     final PhaseTwoSaveProcessor spp2 = new PhaseTwoSaveProcessor();
     spp2.setHelper(helper);
     saveProcessorPhaseTwo = spp2;
 
     final LoadProcessorImpl lp = new LoadProcessorImpl();
     loadProcessor = lp;
 
     final SearchProcessorImpl sp = new SearchProcessorImpl();
     sp.setHelper(helper);
     searchProcessor = sp;
   }
 
   /**
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#shutDown()
    */
   @Override
   public void shutDown()
   {
     LOG.debug("Shutdown neo4j DAO.");
     neo.shutdown();
     neo = null;
   }
 
   /**
    * Setter.
    *
    * @param neo
    *          the neo to set
    */
   public void setNeo(final NeoService neo)
   {
     this.neo = neo;
   }
 
   /**
    * Getter.
    *
    * @return the neo
    */
   public NeoService getNeo()
   {
     return neo;
   }
 
   /**
    * <<<<<<< .mine Setter.
    *
    * @param helper
    *          the helper to set
    */
   public void setHelper(final NeoHelper helper)
   {
     this.helper = helper;
   }
 
   /**
    * Getter.
    *
    * @return the helper
    */
   public NeoHelper getHelper()
   {
     return helper;
   }
 
   /**
    * Setter.
    *
    * @param saveProcessorPhaseOne
    *          the saveProcessorPhaseOne to set
    */
   public void setSaveProcessorPhaseOne(final SaveProcessor saveProcessorPhaseOne)
   {
     this.saveProcessorPhaseOne = saveProcessorPhaseOne;
   }
 
   /**
    * Getter.
    *
    * @return the saveProcessorPhaseOne
    */
   public SaveProcessor getSaveProcessorPhaseOne()
   {
     return saveProcessorPhaseOne;
   }
 
   /**
    * Setter.
    *
    * @param saveProcessorPhaseTwo
    *          the saveProcessorPhaseTwo to set
    */
   public void setSaveProcessorPhaseTwo(final SaveProcessor saveProcessorPhaseTwo)
   {
     this.saveProcessorPhaseTwo = saveProcessorPhaseTwo;
   }
 
   /**
    * Getter.
    *
    * @return the saveProcessorPhaseTwo
    */
   public SaveProcessor getSaveProcessorPhaseTwo()
   {
     return saveProcessorPhaseTwo;
   }
 
   /**
    * Setter.
    *
    * @param loadProcessor
    *          the loadProcessor to set
    */
   public void setLoadProcessor(final LoadProcessor loadProcessor)
   {
     this.loadProcessor = loadProcessor;
   }
 
   /**
    * Getter.
    *
    * @return the loadProcessor
    */
   public LoadProcessor getLoadProcessor()
   {
     return loadProcessor;
   }
 
   /**
    * Setter.
    *
    * @param searchProcessor
    *          the searchProcessor to set
    */
   public void setSearchProcessor(final SearchProcessor searchProcessor)
   {
     this.searchProcessor = searchProcessor;
   }
 
   /**
    * Getter.
    *
    * @return the searchProcessor
    */
   public SearchProcessor getSearchProcessor()
   {
     return searchProcessor;
   }
 
   /**
    * Find all instance models of the model with specified nsURI.
    *
    * @param metaNsUri
    *          Meta model nsURI
    * @return Array of all models namespace URIs having xmlns equals given nsURI.
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#getInstanceModels(java.lang.String)
    */
   @Override
   public String[] getInstanceModels(final String metaNsUri)
   {
     final Transaction tx = neo.beginTx();
     try
     {
       final List<String> instanceModels = new ArrayList<String>();
       // get all availablemodels
       final Iterable<Node> models = helper.getSubrefNodeChildren(EcoreRelationshipType.RESOURCES);
 
       for (final Node model : models)
       {
         // get top level metametamodels
         if (null == metaNsUri || "".equals(metaNsUri))
         {
           // top level metametamodels must not have an incoming INSTANCE MODEL
           // relationship
           if (!model.getRelationships(EcoreRelationshipType.INSTANCE_MODEL, Direction.INCOMING).iterator().hasNext())
           {
             instanceModels.add((String) model.getProperty(Constants.PROPERTY_NS_URI));
           }
         }
         // get any other models
         else
         {
           if (metaNsUri.equals(model.getProperty(Constants.PROPERTY_NS_URI)))
           {
             // get all models having an incoming INSTANCE relationship from this
             // model
             for (final Relationship relationship : model.getRelationships(EcoreRelationshipType.INSTANCE_MODEL,
                 Direction.OUTGOING))
             {
               instanceModels.add((String) relationship.getEndNode().getProperty(Constants.PROPERTY_NS_URI));
             }
           }
         }
       }
       tx.success();
 
       final String[] response = instanceModels.toArray(new String[instanceModels.size()]);
       Arrays.sort(response);
       return response;
     }
     finally
     {
       tx.finish();
     }
   }
 
   /**
    * Checks the existance of a model with the given namespace uri.
    *
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#modelExists(java.lang.String)
    * @param nsUri
    *          a namespace uri
    * @return true, if the given namespace uri exists
    */
   @Override
   public boolean modelExists(final String nsUri)
   {
     LOG.debug("DAO modelExists()");
 
     final Transaction tx = neo.beginTx();
     try
     {
       // search in models (also m1)
       for (final Node modelNode : helper.getSubrefNodeChildren(EcoreRelationshipType.RESOURCES))
       {
         if (((String) modelNode.getProperty(Constants.PROPERTY_NS_URI)).equals(nsUri))
         {
           return true;
         }
         // search in (sub-)packages
         final Node ePackageNode = helper.determineEcoreClassifierNode(EcorePackage.Literals.EPACKAGE.getName());
         if (null != ePackageNode)
         {
           for (final Node packageNode : ePackageNode.traverse(Order.BREADTH_FIRST, StopEvaluator.DEPTH_ONE,
               ReturnableEvaluator.ALL_BUT_START_NODE, EcoreRelationshipType.INSTANCE, Direction.OUTGOING))
           {
             if (nsUri.equals(packageNode.getProperty(Constants.PROPERTY_NS_URI)))
             {
               return true;
             }
           }
         }
       }
     }
     finally
     {
       tx.finish();
     }
     return false;
   }
 
   /**
    * Save {@link Resource}.
    * <p>
    * The resource will be saved under it's nsURI. Any existing model can not be
    * overwritten. In case of existence it must be deleted before saved.
    * <p>
    *
    * @param resource
    *          EMF {@link Resource} to save
    * @throws MRException
    *           Application logic exception
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#save(Resource)
    */
   @Override
   public void save(final Resource resource) throws MRException
   {
     LOG.debug("DAO save()");
 
     final Transaction tx = neo.beginTx();
     try
     {
       // local registry/node cache
       final Map<EObject, Object> registry = new HashMap<EObject, Object>();
 
       /*
        * Phase (1): While this phase all nodes and its containment relationships
        * will be generated.
        */
       saveProcessorPhaseOne.process(resource, registry);
 
       /*
        * Phase (2): While this phase all relationships to the meta model will be
        * generated. Those are any meta-, type- and instance relationships.
        */
       saveProcessorPhaseTwo.process(resource, registry);
 
       tx.success();
     }
     catch (final IllegalStateException e)
     {
       throw new MRException("Could not save model:" + e.getMessage(), e);
     }
     finally
     {
       tx.finish();
     }
   }
 
   /**
    * Loads the model object with the given namespace uri into the given
    * resource.
    * 
    * @param nsUri
    *          a namespace uri
    * @param registry
    *          the registry for loaded objects
    * @return the model to load
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#load(java.lang.String)
    */
   @Override
   public EObject load(final String nsUri, final Map<Object, EObject> registry)
   {
     LOG.debug("DAO load(String)");
     final ResourceSet rset = new ResourceSetImpl();
     rset.getResourceFactoryRegistry().getContentTypeToFactoryMap().put(DEFAULT_CONTENT_TYPE, RESOURCE_FACTORY);
 
     final Transaction tx = neo.beginTx();
     try
     {
       final Node modelNode = helper.getModelNode(nsUri);
       if (null == modelNode)
       {
         return findTopLevelPackage(nsUri, registry);
       }
       else
       {
         for (final Node referenced : modelNode.traverse(Order.BREADTH_FIRST, StopEvaluator.END_OF_GRAPH,
             ReturnableEvaluator.ALL_BUT_START_NODE, EcoreRelationshipType.DEPENDS, Direction.OUTGOING,
             EcoreRelationshipType.INSTANCE_MODEL, Direction.INCOMING))
         {
           final String uri = (String) referenced.getProperty(Constants.PROPERTY_NS_URI);
           final XMIResource resource = (XMIResource) rset.createResource(URI.createURI(uri));
           resource.getContents().add(load(uri, registry));
         }
         return loadProcessor.process(modelNode, registry);
       }
     }
     finally
     {
       tx.finish();
     }
   }
 
   /**
    * Finds an instance of EPackage with given nsUri and returns its top level
    * package.
    *
    * @param nsUri
    *          the namespace uri
    * @param registry
    *          the registry of the load process
    * @return the top level package
    */
   private EPackage findTopLevelPackage(final String nsUri, final Map<Object, EObject> registry)
   {
     final Node ePackageNode = helper.determineEcoreClassifierNode(EcorePackage.Literals.EPACKAGE.getName());
     for (final Node pkgNode : ePackageNode.traverse(Order.BREADTH_FIRST, StopEvaluator.DEPTH_ONE,
         ReturnableEvaluator.ALL_BUT_START_NODE, EcoreRelationshipType.INSTANCE, Direction.OUTGOING))
     {
       if (nsUri.equals(pkgNode.getProperty(Constants.PROPERTY_NS_URI)))
       {
         Node container = pkgNode;
         while (container.hasRelationship(EcoreRelationshipType.CONTAINS, Direction.INCOMING))
         {
           container = container.getSingleRelationship(EcoreRelationshipType.CONTAINS, Direction.INCOMING).getStartNode();
         }
         return (EPackage) load((String) container.getProperty(Constants.PROPERTY_NS_URI), registry);
       }
     }
     return null;
   }
 
   /**
    * Deletes the model with the given namespace uri.
    *
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#delete(String,
    *      boolean)
    * @param nsUri
    *          a namespace uri
    * @param cascading
    *          whether cascading delete model instances of current model.
    * @throws MRException
    *           Application logic exception
    */
   @Override
   public void delete(final String nsUri, final boolean cascading) throws MRException
   {
     LOG.debug("DAO delete()");
 
     final Transaction tx = neo.beginTx();
     try
     {
       for (final Node modelNode : helper.getSubrefNodeChildren(EcoreRelationshipType.RESOURCES))
       {
         if (nsUri.equals(modelNode.getProperty(Constants.PROPERTY_NS_URI)))
         {
           deleteContent(modelNode, cascading);
           tx.success();
           return;
         }
       }
 
       throw new MRException("Could not find model with nsUri:" + nsUri);
     }
     finally
     {
       tx.finish();
     }
   }
 
   /**
    * Deletes the given node and its content recursively.
    *
    * @param modelNode
    *          the node to delete
    * @param cascading
    *          whether cascading delete model instances of current model.
    * @throws MRException
    *           Application logic exception
    */
   private void deleteContent(final Node modelNode, final boolean cascading) throws MRException
   {
     // All nodes this node directly and indirectly contains
     final Iterable<Node> contents =
         modelNode.traverse(Order.DEPTH_FIRST, StopEvaluator.END_OF_GRAPH, ReturnableEvaluator.ALL,
             EcoreRelationshipType.CONTAINS, Direction.OUTGOING);
 
     if (modelNode.hasRelationship(EcoreRelationshipType.DEPENDS, Direction.INCOMING))
     {
       final StringBuilder message = new StringBuilder("Could not delete model. Please first delete models that depend on it: ");
       final List<Node> dependentModels = new ArrayList<Node>(modelNode.traverse(Order.BREADTH_FIRST, StopEvaluator.DEPTH_ONE,
           ReturnableEvaluator.ALL_BUT_START_NODE, EcoreRelationshipType.DEPENDS, Direction.INCOMING).getAllNodes());
       for (int i = 0; i < dependentModels.size(); i++)
       {
          message.append((String) dependentModels.get(i).getProperty(Constants.PROPERTY_NS_URI))
             .append(
             i < dependentModels.size() - 1 ? ", " : ".");
       }
       throw new MRException(message.toString());
     }
     if (modelNode.hasRelationship(EcoreRelationshipType.INSTANCE_MODEL, Direction.OUTGOING))
     {
       if (cascading)
       {
         for (final Relationship relationship : modelNode.getRelationships(EcoreRelationshipType.INSTANCE_MODEL,
             Direction.OUTGOING))
         {
           deleteContent(relationship.getEndNode(), cascading);
         }
         // if this model has instance models and no cascading delete is allowed,
         // reject proceeding of delete
       }
       else
       {
         throw new MRException("You have to delete instance models of this model first!");
       }
     }
 
     // delete this model and all of its contents
     for (final Node node : contents)
     {
       if (node.hasRelationship())
       {
         for (final Relationship relationship : node.getRelationships())
         {
           relationship.delete();
         }
       }
       node.delete();
     }
   }
 
   /**
    * Finds all instances of given classifiers that contain given expression.
    *
    * @param expression
    *          the expression to search for
    * @param classifiers
    *          the classifiers to search in
    * @param isRegEx
    *          RegExp search
    * @param isCaseSensitive
    *          Case sensitive search
    * @return the array of found models matching the given expression
    * @see de.uni_leipzig.wifa.iwi.mr3.dao.ModelRepositoryDao#find(java.lang.String,
    *      java.lang.String[])
    */
   @Override
   public Match[] find(final String expression, final String[] classifiers, final boolean isRegEx, final boolean isCaseSensitive)
   {
     LOG.debug("DAO find()");
 
     Arrays.sort(classifiers);
 
     final int eObjectPos = Arrays.binarySearch(classifiers, EcorePackage.Literals.EOBJECT.getName());
     final boolean containsEObject = eObjectPos >= 0;
     final Transaction tx = neo.beginTx();
     try
     {
       if (containsEObject)
       {
         return searchProcessor.processCompleteSearch(expression, classifiers, isCaseSensitive, isRegEx);
       }
       return searchProcessor.processPartialSearch(expression, classifiers, isCaseSensitive, isRegEx);
     }
     finally
     {
       tx.finish();
     }
   }
 }