package org.molwind.chemical.model;
   
   /*
    * This file is part of Molwind.
    *
    * Molwind is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * Molwind is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Molwind. If not, see <http://www.gnu.org/licenses/>.
   */
  
  import org.molwind.graph.DefaultEntityGraph;
  import org.molwind.graph.EntityGraph;
  import org.molwind.graph.EntityGraphAnalyzer;
  import org.molwind.graph.EntityVertex;
  import org.molwind.model.Identity;
  import org.molwind.model.PartOf;
  import org.molwind.model.Relationship;
  import org.molwind.model.RelationshipResolver;
  import org.molwind.model.WorldEntity;
  import org.molwind.util.MolwindLogger;
  import org.openscience.cdk.tools.MFAnalyser;
  
  import org.openscience.cdk.interfaces.IMolecule;
  
  /**
   * SubstructureResolver resolves substructure relationships.
   *
   * @author <a href="mailto:oliver.karch@molwind.org">Oliver Karch</a>
   * @version 1.0
   */
  public class SubstructureResolver
  implements RelationshipResolver, EntityGraphAnalyzer, Identity {
  
      
      
      private EntityGraph compounds;
      private boolean analyzed;
      
      private String idName;
     
      private String parentName;
  
      /**
       * Get the ParentName value.
       * @return the ParentName value.
       */
      public String getParentName(){
  
  	return parentName;
      }
  
      /**
       * Set the ParentName value.
       * @param newParentName The new ParentName value.
       */
      public void setParentName(String newParentName) {
  	this.parentName = newParentName;
      }
  
      
  
      /**
       * Creates a new Substructure resolver which uses the given attributes to
       * decide whether there is a relationship.
       *
       * @param newParentName
       *      the parent attribute's name
       * @param newIdName
       *      the id attribute's name
       */
      public SubstructureResolver(final String newParentName,
              final String newIdName) {
          parentName = newParentName;
  
          idName = newIdName;
          analyzed = false;
          compounds = new DefaultEntityGraph();
      }
      
  
      private  double getMolecularWeight(IMolecule molecule){
  	if(molecule==null) return 0.0F;
  	
  	MFAnalyser mfa = new MFAnalyser(molecule);
  	try {
  	    return mfa.getCanonicalMass();
  	} catch (Exception e) {
  	    return 0.0f;
  	}
 	
 	
 	
     }
     
  
 
 
     private String getId(final ChemicalEntity chemicalEntity) {
         String id = chemicalEntity.getAttribute(idName);
 
         if (id == null) {
             id = String.valueOf(System.currentTimeMillis());
             chemicalEntity.setAttribute(idName, id);
         }
         return id;
     }
 
     private boolean addRelation(final ChemicalEntity chemicalEntity1,
             final ChemicalEntity chemicalEntity2) {
         if ((chemicalEntity1 == null) || (chemicalEntity2 == null)) {
             return false;
         }
 
         PartOf relation = new PartOf(chemicalEntity1, chemicalEntity2);
         chemicalEntity1.addRelationship(relation);
         chemicalEntity2.addRelationship(relation);
 
         String id1 = getId(chemicalEntity1);
         String id2 = getId(chemicalEntity2);
 	
 	IMolecule molecule1 = chemicalEntity1.getMolecule();
 	IMolecule molecule2 = chemicalEntity2.getMolecule();
 	
 	int edgeWeight = molecule1.getAtomCount()+molecule2.getAtomCount();
 
         compounds.addEntity(id1, chemicalEntity1);
         compounds.addEntity(id2, chemicalEntity2);
         compounds.addEdge(id1, id2, relation,edgeWeight);
 
 
         return true;
     }
 
 
     /**
      * Augments the relationship between two entities.
      *
      * @param entity1
      *      a world entity
      * @param entity2
      *      another world entity
      * @return
      *      true if any relationship could be established, false otherwise
      */
     public boolean related(final WorldEntity entity1,
             final WorldEntity entity2) {
 
         if ((entity1 == null)
                 || (entity2 == null)
                 || !(entity1 instanceof ChemicalEntity)
                 || !(entity2 instanceof ChemicalEntity)) {
             return false;
         }
 
         ChemicalEntity chemicalEntity1 = (ChemicalEntity) entity1;
         ChemicalEntity chemicalEntity2 = (ChemicalEntity) entity2;
         String parentId1 = chemicalEntity1.getAttribute(parentName);
         String id1 = getId(chemicalEntity1);
         String parentId2 = chemicalEntity2.getAttribute(parentName);
         String id2 = getId(chemicalEntity2);
 
 	       
 	 
 	boolean related = false;
         if (parentId1 != null) {
             if (parentId1.equals(id2)) {
                 return addRelation(chemicalEntity1, chemicalEntity2);
             } else {
                 related = addRelation(chemicalEntity1,
                         (ChemicalEntity) compounds.findEntity(parentId1));
             }
         }
 
         if (parentId2 != null) {
             if (parentId2.equals(id1)) {
                 return addRelation(chemicalEntity2, chemicalEntity1);
             } else {
                 related = addRelation(chemicalEntity2,
                         (ChemicalEntity) compounds.findEntity(parentId2));
             }
         }
 
         if (!related) {
             compounds.addEntity(id1, chemicalEntity1);
             compounds.addEntity(id2, chemicalEntity2);
         }
 
         return false;
     }
 
     /**
      * Resolves the relationships by creating a graph of entity vertices and
      * relationship edges.
      *
      * @return
      *      the resulting entity graph
      */
     public EntityGraph resolve() {
         if (!analyzed) {
             compounds.analyze(this);
             analyzed = true;
         }
         return compounds;
     }
 
     /**
      * Analyzes an entity graph.
      *
      * @param graph
      *      the graph to be analyzed
      * @param vertex
      *      the current vertex
      * @return
      *      returning false stops analysis immediately
      */
     public boolean analyze(final EntityGraph graph,
             final EntityVertex vertex) {
         ChemicalEntity chemicalEntity1 = (ChemicalEntity) vertex.getEntity();
         String parentId = chemicalEntity1.getAttribute(parentName);
         if (parentId == null) {
             return true;
         }
 
         ChemicalEntity chemicalEntity2 =
             (ChemicalEntity) graph.findEntity(parentId);
         if (chemicalEntity2 == null) {
             MolwindLogger.warn("Missing parent id " + parentId, null);
             return true;
         }
 
         Relationship[] relations =
             chemicalEntity1.hasRelationship(chemicalEntity2);
         if (relations.length > 0) {
             return true;
         }
 
         PartOf relation = new PartOf(chemicalEntity1, chemicalEntity2);
         chemicalEntity1.addRelationship(relation);
         chemicalEntity2.addRelationship(relation);
         return true;
     }
 
     /**
      * Tests whether two entities are identical.
      *
      * @param entity1
      *      the first entity
      * @param entity2
      *      the second entity
      * @return
      *      true if the two entities are identical
      */
     public boolean identical(final WorldEntity entity1,
             final WorldEntity entity2) {
         String id1 = getId((ChemicalEntity) entity1);
         String id2 = getId((ChemicalEntity) entity2);
         return id1.equals(id2);
     }
 
 }