package com.explosion.utilities;
   
   import java.io.File;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   
   import com.explosion.utilities.regex.RegExpFileAndDirectoryFilter;
   import com.explosion.utilities.regex.RegExpFileNameFilter;
  
  /*
   * =============================================================================
   * 
   * Copyright 2004 Stephen Cowx
   * 
   * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   * 
   * http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   * 
   * =============================================================================
   */
  
  /***
   * A really handy class which will pass back to you all the files in a directory
   * recursively one at a time whenever one is asked for.
   * 
   * @author Stephen Created on May 5, 2004
   */
  public class FileIterator
  {
  
      //private static Logger log = LogManager.getLogger(FileIterator.class);
      
      private boolean recursive = false;
      private boolean excludeDirectories = true;
      private boolean caseSensitive = false;
      private boolean hasNext = true;
      
      private String fileNamePattern = null;
      private RegExpFileAndDirectoryFilter regExpAndDirectoryFilter;
      private RegExpFileNameFilter regExpFilter;
      private List fileList = new ArrayList();
      private FileIterator activeIterator;
      private File currentFile = null;
      private File fileToReturn = null;
      
      private int index = 0;
      private int recursionLevel = 0;
      private int numberOfFiles = 0;
      private int numberOfDirectories = 0;
  
      /***
       * Creates a file iterator object with the provided arguments
       * @param directory directory to look in
       * @param pattern regexp pattern of filename to look for
       * @param caseSensitive regexp matching to be case sensitive or not
       * @param recursive find files recursively
       * @param excludesDirectories will not return any directories if set to true
       */
      public FileIterator(String directory, String fileNamePattern, boolean caseSensitive, boolean recursive, boolean excludeDirectories) throws IOException
      {
          this.recursive = recursive;
          this.caseSensitive = caseSensitive;
          this.excludeDirectories = excludeDirectories;
          this.fileNamePattern = (fileNamePattern == null ? "" : fileNamePattern);
          regExpFilter = new RegExpFileNameFilter(fileNamePattern, caseSensitive);
          File sourceDirectory = new File(directory);
  
          /* Checking */
          if (!sourceDirectory.exists())
              throw new IOException("Unable to find path specified for creating a list of files: " + directory);
  
          if (!sourceDirectory.isDirectory())
              throw new IOException("Path specified for creating a list of files is not a directory : " + directory);
  
          if (!recursive && excludeDirectories)
          {
              /* Initilaise the regExpAndDirectoryFilter */
              regExpAndDirectoryFilter = new RegExpFileAndDirectoryFilter(regExpFilter);
              File[] files = sourceDirectory.listFiles(regExpAndDirectoryFilter);
              for (int i = 0; i < files.length; i++)
                  fileList.add(files[i]);
  
             // log.debug(getRecursionLevelString() + "New iterator for [" + sourceDirectory + "] contains " + fileList);
          }
          else
          {
              File[] files = sourceDirectory.listFiles();
              for (int i = 0; i < files.length; i++)
              {
                  if (files[i].isDirectory() || regExpFilter.accept(files[i].getParentFile(), files[i].getName()))
                 {
                     fileList.add(files[i]);
                     if (files[i].isDirectory())
                         numberOfDirectories++;
                     else
                         numberOfFiles++;
                 }
             }
            // log.debug(getRecursionLevelString() + "New iterator for [" + sourceDirectory + "] contains " + fileList);
         }
         
         /* Initialise currentFile  */
         if (fileList.size() > 0)
         {
             index = 0;
             currentFile = (File) fileList.get(index);
         }
     }
 
     /***
      * Returns a boolean stating whether there are any more files in the
      * iterator.
      * 
      * @return
      */
     public boolean hasNext() throws IOException
     {
         if (currentFile == null)
             return false;
         else
         {
           fileToReturn = getNext();
           return fileToReturn != null;
         }
     }
 
     public File getNext() throws IOException
     {
         if (currentFile.isDirectory())
         {
             if (recursive)
             {
                /* First return all of the files in this directoy and then return return the directory itself if !exclude directories */
                
                /* 1.) We need an iterator for the files in this directory */
                if (activeIterator == null)
                {
                   activeIterator = new FileIterator(currentFile.getAbsolutePath(), fileNamePattern, caseSensitive, recursive, excludeDirectories);
                   activeIterator.recursionLevel=recursionLevel++;
                }
                
                /* If this directory has any files/directories in it then we want to return all of them first */
                if (activeIterator.hasNext())
                {
                    return activeIterator.next();  
                }
                else
                {
                    /* Null the activeIterator so that it will reinitialise a new one for the next directory we find */
                    activeIterator = null;
                    
                    /* Otherwise we want to return this directory if !excludeDirectories  or we want to start everything all over again with the next file in this iterator*/
                    if (excludeDirectories)
                    {
                        /* Move on to the next file */
                        transitionIterator();
                        if (currentFile == null)
                        {
                            /* There are no more files */
                            return null;
                        }
                        else
                        {
                            /* Scan until we find one */
                            return getNext();
                        }
                    }
                    else
                    {
                        /* It is safe to fall down to the bottom and return the current file */
                    }
                }
             }
             else
             {
                 /* If it is not recursive and this is a directory then exclude directories must be false */
                 //assert excludeDirectories == false : "Expected excludeDirectories to be false but it was true";
                 /* It is safe to fall down to the bottom and return the current file */
             }
         }
         
         File returnValue = currentFile;
         transitionIterator();
         //log.debug(getRecursionLevelString() + "Found file " + returnValue);
         return returnValue;        
     }
     
     private String getRecursionLevelString()
     {
         String string = new String();
         for (int i=0;i<recursionLevel;i++)
         {
             string += "   ";
         }
         return string;
     }
     
     /***
      * This method incremenets the iterator and looks after the 
      * index, hasNext and currentFile variables  
      *
      */
     private void transitionIterator()
     {
         index++;
         if (index < fileList.size())
         {
             /* this means that there are still more files / directories to come */
             currentFile = (File) fileList.get(index);
         }
         else
         {
             currentFile = null;
         }
     }
     
     /***
      * Returns the next file in this iterator
      * 
      * @return
      */
     public File next() throws IOException
     {
         return fileToReturn;
     }
     
     /***
      * At best a rough guide.  It basically just gives you the result of the progress through the top level of files.
      * @return int percent complete
      */
     public int getPercentComplete()
     {
         if (fileList.size() == 0) 
           return 100;
         else
           return ( index / fileList.size() ) * 100;
     }
 
     /***
      * @return Returns the caseSensitive.
      */
     public boolean isCaseSensitive()
     {
         return caseSensitive;
     }
     /***
      * @return Returns the excludeDirectories.
      */
     public boolean isExcludeDirectories()
     {
         return excludeDirectories;
     }
     /***
      * @return Returns the numberOfDirectories.
      */
     public int getNumberOfDirectories()
     {
         return numberOfDirectories;
     }
     /***
      * @return Returns the numberOfFiles.
      */
     public int getNumberOfFiles()
     {
         return numberOfFiles;
     }
     
     /***
      * Returns the total number of items in this iterator
      * @return
      */
     public int getNumberOfItems()
     {
         return fileList.size();
     }
     /***
      * @return Returns the recursive.
      */
     public boolean isRecursive()
     {
         return recursive;
     }
 }