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.FilenameFilter;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Iterator;
  
  import org.apache.commons.io.filefilter.SuffixFileFilter;
  
  import org.molwind.chemical.model.ChemicalWorld;
  import org.molwind.chemical.model.SubstructureResolver;
  import org.molwind.io.AbstractWorldLocator;
  import org.molwind.io.BasePathSupport;
  import org.molwind.model.MolwindWorld;
  import org.molwind.util.Stringx;
  
  /**
   * SDFileLocator implements a locator to find worlds based on SDF chemical file
   * format.
   *
   * @author <a href="mailto:oliver.karch@molwind.org">Oliver Karch</a>
   * @version 1.0
   */
  public class SDFileLocator  extends AbstractWorldLocator implements BasePathSupport  {
  
      private ArrayList suffixes;
      private String parentAttributeName;
      private String idAttributeName;
      private ArrayList<String> basePaths;
  
      /**
       * The relativ adress for looking up the worlds
       *
       */
      public static String pathNames;
  
      /**
       * The default file extensions recognized by this locator.
       */
      public static final String[] DEFAULT_SDF_SUFFIX = {
          ".sdf", ".SDF", ".mol", ".MOL"
      };
  
      /**
       * The default name of the attribute denoting the parent.
       */
      public static final String DEFAULT_PARENT_ATTRIBUTE = "parent";
  
      /**
       * The default name of the attribute denoting the id.
       */
      public static final String DEFAULT_ID_ATTRIBUTE = "compoundid";
      /**
       *
       * The default value for seperating a path
       */
      public static final String  DEFAULT_PATH_SEPARATOR = ":"; 
  
      /**
       * Creates an SDFilelocator instance.
       */
      public SDFileLocator() {
          suffixes = new ArrayList( Arrays.asList(DEFAULT_SDF_SUFFIX));
          setParentAttributeName(DEFAULT_PARENT_ATTRIBUTE);
          setIdAttributeName(DEFAULT_ID_ATTRIBUTE);
  	basePaths = new ArrayList<String>();
      }
  
      /**
       * Adds a path to the base paths 
       * @param path
       *        the path to be add
       *
       */
      public void addBasePath(final String path){
  	basePaths.add(path);
  
      }
      /**
       * Removes the given path from the base paths
      *
      * @param path
      *       the path to be removed
      */
     public void removeBasePath(final String path){
 
 	basePaths.remove(path);
     }
 
       /**
      * Locates the world by the given name by iteraring all world names
      *
      * @param 
      *      the filename
      * @return 
      *      a molwind world descriptor
      * @throws java.io.IOException
      *      is thrown upon i/o error
      */
     public MolwindWorld locateByFileName(String fileName)
     throws IOException{
 	//File file
 	String[] worldNames = getWorldNames();
 	for(String s:worldNames){
 	    if(s.contains(fileName) && isChemicalFile(s)){
 		ChemicalWorld chemicalWorld = new ChemicalWorld(fileName,new File(s));
 		chemicalWorld.setRelationshipResolver(new SubstructureResolver(getParentAttributeName(),getIdAttributeName()));
 		return (MolwindWorld)chemicalWorld;
 	    
 	    }
 		 
 	}
 	
 	return null;
 	
     }
   
     
     private boolean isChemicalFile(String path){
 	File file = new File(path);
 	if(!file.exists())
 	    return false;
 	Iterator it = suffixes.iterator();
 	while(it.hasNext()){
 	    String suffix = (String)it.next();
 	 
 	    String[] suffixArray = new String[suffixes.size()];
 	    SuffixFileFilter suffixFileFilter = new SuffixFileFilter((String[])suffixes.toArray(suffixArray));
 	    
 	    if(suffixFileFilter.accept(file))
 		return true;
 	    
 	}
 	
 	return false;
 	
     }
 
     /**
      * Locates a world with the given name.
      *
      * @param worldName
      *      the name of the world
      * @return
      *      a molwind world descriptor
      * @throws java.io.IOException
      *      is thrown upon i/o error
      */
     public MolwindWorld locateWorld(final String worldName)
     throws IOException {
         File file = new File(worldName);
         if (file.exists() && file.isFile()) {
 	    
             ChemicalWorld chemicalWorld = new ChemicalWorld(
                     toWorldName(file), file);
             chemicalWorld.setRelationshipResolver(
                     new SubstructureResolver(
                             getParentAttributeName(), getIdAttributeName()));
             return (MolwindWorld) chemicalWorld;
         }
 
         if (file.exists() && file.isDirectory()) {
             ChemicalWorld chemicalWorld = new ChemicalWorld(file.getName());
             chemicalWorld.setRelationshipResolver(
                     new SubstructureResolver(
                             getParentAttributeName(), getIdAttributeName()));
 
             Iterator it = suffixes.iterator();
             while (it.hasNext()) {
                 String suffix = (String) it.next();
                 File[] files = file.listFiles(
                         (FilenameFilter) new SuffixFileFilter(suffix));
 
                 for (int i = 0; i < files.length; i++) {
                     chemicalWorld.addFile(files[i]);
                 }
             }
             return (MolwindWorld) chemicalWorld;
         }
 
         Iterator it = suffixes.iterator();
         while (it.hasNext()) {
             String suffix = (String) it.next();
             file = new File(Stringx.strapp(worldName, suffix));
             if (file.exists()) {
                 ChemicalWorld chemicalWorld = new ChemicalWorld(
                         toWorldName(file), file);
                 chemicalWorld.setRelationshipResolver(
                         new SubstructureResolver(getParentAttributeName(),
                                 getIdAttributeName()));
                 return (MolwindWorld) chemicalWorld;
             }
         }
 
         return null;
     }
 
 
     private String[] getWorldPath(String[] suffixes){
 	ArrayList<String> wPaths = new ArrayList<String>();
 	for(String s:suffixes){
 	    File file = new File(s);
 	    if(file.isAbsolute()){
 		wPaths.add(s);
 	    
 	    }else{
 		for(String bp:basePaths){
 		    
 		    String pathName=bp+s;
 		    wPaths.add(bp);
 		}
 
 	    }
 	    
 	}
 
 
 
 	String[] hPaths = new String[ wPaths.size() ];
 	return (String[])wPaths.toArray( hPaths );
 	
     }
 
 
     /**
      * private String[] getWorldPaths( String[] suffixes(relative namen) ) {
      *ArrayList<String> wPaths = new ArrayList<String>() 
      *    for(String s:suffixes) {
      *	if( File(s).isAbsolute() )
      *	    wPaths.add( s );
      *	else {
      *	    
      *
      *    }
      * hPaths = new String[ wPaths.size() ];
      * return (String[])wPaths.toArray( hPaths );
     */
 
     /**
      *
      *@return 
      *    returns an array of available worlds
      *
      */
 
     public String[] getWorldNames(){
 	//	String[] paths = getWorldPaths(pathNames.split(DEFAULT_PATH_SEPARATOR));
 	String[] paths = pathNames.split(DEFAULT_PATH_SEPARATOR);
 
 	ArrayList<String> result = new ArrayList<String>();
 
 	for(String s:paths){
 	    File file = new File(s);
 	    if(file.exists() && file.isFile()){
 	 
 		result.add(s);
 		
 	    }else if(file.exists() && file.isDirectory()){
 		try{
 		    result.add(s);
 		    
 		    iterateDirectory(s,result);
 		}catch(Exception e){
 		    e.printStackTrace();
 		}
 
 	    }
 	     Iterator it = suffixes.iterator();
 	     while (it.hasNext()) {
 		 String suffix = (String) it.next();
 		 file = new File(Stringx.strapp(s, suffix));
 		 if (file.exists()) {
 		    
 		     result.add(toWorldName(file));
 		 }
 	     }
 	   
                
 			           
 	}
 	
 
 	String[] resultArray = new String[result.size()];
 	
 
         return (String[])result.toArray(resultArray) ;
     }
 
    
    
 
 
 
 
     private void iterateDirectory(String dPath,ArrayList<String> result)throws Exception
     {
 	
 	File file = new File(dPath);
    
 		
 	
 	File[] files = file.listFiles();
 
 	for(File f:files){
 	    if(f.exists() && f.isFile()){                  
 	
 
 
 	       
 			result.add(dPath+"/"+f.getName());
 	       
 	    }else if(f.exists() && f.isDirectory()){
 	      
 	      	result.add(dPath+"/"+f.getName());
 	       	iterateDirectory(dPath+"/"+f.getName(),result);
 		
 	    }
 		    
 
 	}
 	   
     
 	
     }
 
 
     private String toWorldName(final File file) {
         
         return file.getName();
     }
     
 
 
 
     
 
 
     /**
      * Get the <code>parentAttributeName</code> value.
      *
      * @return
      *      the <code>parentAttributeName</code> value
      */
     public String getParentAttributeName() {
         return parentAttributeName;
     }
 
     /**
      * Set the <code>ParentAttributeName</code> value.
      *
      * @param newParentAttributeName
      *      the new <code>ParentAttributeName</code> value
      */
     public void setParentAttributeName(final String newParentAttributeName) {
         this.parentAttributeName = newParentAttributeName;
     }
 
     /**
      * Get the <code>idAttributeName</code> value.
      *
      * @return
      *      the <code>idAttributeName</code> value
      */
     public String getIdAttributeName() {
         return idAttributeName;
     }
 
     /**
      * Set the <code>idAttributeName</code> value.
      *
      * @param newIdAttributeName
      *      the new <code>idAttributeName</code> value
      */
     public void setIdAttributeName(final String newIdAttributeName) {
         this.idAttributeName = newIdAttributeName;
     }
     /**
      * Set the <code>pathNames</code> 
      * @param paths
      *        the new <code>pathNames</code> value
      */
 
     public void setPathNames(final String paths) {
         this.pathNames = paths;
     }
      /**
      * Get the worldpaths
      *
      *@return 
      *      worldpaths
      *
      */
     public String getPathNames(){
 	return this.pathNames;
 
     }
 
 
     
 
 }