package org.molwind.chemical.io;
   
   /*
    * 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 java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  
  import org.openscience.cdk.DefaultChemObjectBuilder;
  import org.openscience.cdk.interfaces.IMolecule;
  import org.openscience.cdk.io.iterator.IteratingMDLReader;
  
  
  import org.molwind.chemical.model.ChemicalEntity;
  import org.molwind.graph.DefaultEntityGraph;
  import org.molwind.graph.EntityGraph;
  import org.molwind.model.Identity;
  import org.molwind.model.RelationshipResolver;
  import org.molwind.util.MolwindLogger;
  
  /**
   * SDFileIterator reads sdf formatted files of chemical compounds.
   *
   * @author <a href="mailto:oliver.karch@molwind.org">Oliver Karch</a>
   * @version 1.0
   */
  public class SDFileIterator implements Iterator {
  
      private ArrayList<File> files;
      private Iterator fileIterator;
      private Iterator entityIterator;
      private IteratingMDLReader sdfReader=null;
      private RelationshipResolver relationshipResolver;
      private String parentName;
      private ChemicalEntity currentEntity;
      private ChemicalEntity lastEntity;
      private EntityGraph compounds;
      
  
      /**
       * Creates a new chemical entity iterator based on the underlying SD files
       * using the given relationship resolver.
       *
       * @param theFiles
       *      array of one or more file
       * @param resolver
       *      the relationship resolver strategy
       */
      public SDFileIterator(final File[] theFiles,
              final RelationshipResolver resolver) {
          files =  new ArrayList<File>();
  	for(File f:theFiles){
  	    files.add(f);
  	}
  
  	fileIterator = null;
          entityIterator = null;
          sdfReader = null;
          relationshipResolver = resolver;
  	parentName = relationshipResolver.getParentName();
          currentEntity = null;
          lastEntity = null;
          compounds = null;
      }
      
  
      
      private ChemicalEntity readNext()
  	throws IOException {
  	
  	
          if (sdfReader == null || !sdfReader.hasNext()) {
  	    
  	    
  
  
              if (fileIterator == null) {
                  fileIterator = files.iterator();
              }
              if (sdfReader != null) {
 		sdfReader.close();
 		return null;
             }
             if (!fileIterator.hasNext()) {
 		
                 return null;
             }
 	    
             File file = (File) fileIterator.next();
             FileReader fileReader = new FileReader(file);
             sdfReader = new IteratingMDLReader(fileReader,
 					       DefaultChemObjectBuilder.getInstance());
 	    
             if (!sdfReader.hasNext()) {
 		
                 sdfReader.close();
 
                 return null;
             }
         }
 	
 	IMolecule molecule = (IMolecule) sdfReader.next();
 	String parentId =(String) molecule.getProperty(parentName);
 	
 	ChemicalEntity chemicalEntity = new ChemicalEntity(molecule);
 	chemicalEntity.setAttribute(parentName,parentId);
 	if ((relationshipResolver != null)
 	    && (relationshipResolver instanceof Identity)) {
 	    chemicalEntity.setIdentity((Identity) relationshipResolver);
 	}
 	
         return chemicalEntity;
     }
     
 
    
     
     /**
      * Sets the file reader
      * 
      * @param 
      *       the file to be read
      */
     public void setFileReader(File f) 
 	throws IOException{
 	FileReader fileReader = new FileReader(f);
 	sdfReader = new IteratingMDLReader(fileReader,DefaultChemObjectBuilder.getInstance());
 
     }
 
     /**
      * Sets the file reader
      * 
      * @param 
      *       the filename of the file  to be read
      */
     public void setFileReader(String name){
 	File source=null;
 	for(File f:files){
 	    
 	    if(f.getName().contains(name)){
 		
 		source=f;
 		break;
 	    }
 	}
 	try{
 	    FileReader fileReader = new FileReader(source);
 	    sdfReader = new IteratingMDLReader(fileReader,DefaultChemObjectBuilder.getInstance());
 	}catch(java.io.FileNotFoundException fne){
 	    fne.printStackTrace();
 	}
 
     }
     
     /**
      * Returns the Graph for the given file
      *
      * @return 
      *       an object from DefaultEntityGraph
      *
      */
     public DefaultEntityGraph getDefaultEntityGraph()
     	throws IOException{
 	DefaultEntityGraph defaultEntityGraph = (DefaultEntityGraph) getGraph();
 	defaultEntityGraph.devideLayers();
 	return defaultEntityGraph;
     }
 
     private EntityGraph getGraph()
     throws IOException {
 
         if (compounds == null) {
 
 	   
             ChemicalEntity currentEntity = null;
             ChemicalEntity lastEntity = null;
 	    int i = 0;
             while ((currentEntity = readNext()) != null) {
 	
                 if ((relationshipResolver != null) && (lastEntity != null)) {
                     relationshipResolver.related(lastEntity, currentEntity);
                 }
 
                 lastEntity = currentEntity;
 	   
             }
 	   
             if (relationshipResolver != null) {
 			    
 	
                 compounds = relationshipResolver.resolve();
 
             } else {
                 compounds = new DefaultEntityGraph();
             }
         }
 	
         return compounds;
     }
 
 
     /**
      * Returns true if the iteration has more elements.
      *
      * @return
      *      true if the iterator has more elements
      */
     public boolean hasNext() {
         if (entityIterator == null) {
             try {
                 compounds = getGraph();
             } catch (IOException ioe) {
                 MolwindLogger.error(ioe);
                 throw new NoSuchElementException(ioe.getMessage());
             }
             entityIterator = compounds.iterator();
         }
         return entityIterator.hasNext();
     }
     
    
 	
 	
     
 
     /**
      * Returns the next element in the iteration.
      *
      * @return
      *      the next element in the iteration
      */
     public Object next() {
         if (entityIterator != null) {
             return entityIterator.next();
         } else {
             return null;
         }
     }
 
     /**
      * Removes from the underlying collection the last element returned by the
      * iterator. This operation is not supported.
      */
     public void remove() {
         throw new UnsupportedOperationException();
     }
 
 }