/*
    * Fsgrep is a simple Java application which allows a user to
    * search all files in a directory structure for lines matching
    * a given pattern.  Its functionality is a combination of the
    * Unix 'find' and 'grep' utilities.
    * Visit [http://fsgrep.sourceforge.net/] for more information.
    * 
    * Copyright (C) 2003-2006 Murali Krishnan [murali_ca_us@users.sourceforge.net]
    * 
   * Fsgrep is free software; you can redistribute it and/or modify
   * it under the terms of version 2 of the GNU General Public
   * License as published by the Free Software Foundation.
   * 
   * Fsgrep 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 Fsgrep (see the file named LICENSE.txt); if not, write
   * to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   * Boston, MA  02111-1307  USA
   */
  
  package mk.fsgrep.util;
  
  import java.io.*;
  import java.util.*;
  
  /***
   * A wrapper for the File object which caches the canonical name and the
   * suffix, so these do not have to be determined multiple times.
   * 
   * @author  Murali Krishnan
   *
   */
  public class TargetFile implements Comparable {
  
      //------------------------------------------------------------
      //- Class Variables
  
  
  
      //------------------------------------------------------------
      //- Class Functions
  
  
  
      //------------------------------------------------------------
      //- Instance Variables
  
      private File vFile = null;
      private String vSuffix = null;
      private String vName = null;
      private LineNumberReader vLineNumberReader = null;
      private Collection<Integer> vFilterNumbers = new HashSet<Integer>();
  
  
  
      //------------------------------------------------------------
      //- Constructors
  
      public TargetFile(String pFilename) {
          this (new File(pFilename));
      }
  
  
      public TargetFile(File pFile) {
          vFile = pFile;
  
          {   // Parse the suffix from the file name.
              if (vFile.isFile()) {
                  String string = vFile.getName();
                  int index = string.lastIndexOf('.');
                  if (index != -1) {
                      vSuffix = string.substring(index+1);
                  }
              }
          }
      }
  
  
      public TargetFile(File pFile, String pSuffix) {
          vFile = pFile;
          vSuffix = pSuffix;
      }
  
  
      protected TargetFile() {
      }
  
  
      //------------------------------------------------------------
      //- Accessors
  
      public File getFile() {
          return vFile;
      }
  
     public String getSuffix() {
         return vSuffix;
     }
 
     public String getName() {
         if (vName == null) {
             try {
                 vName = getFile().getCanonicalPath();
             } catch (IOException ioe) {
                 vName = getFile().getAbsolutePath();
             }
         }
 
         return vName;
     }
 
     protected LineNumberReader getLineNumberReader() {
         return vLineNumberReader;
     }
 
     public Collection<Integer> getFilterNumbers() {
         return vFilterNumbers;
     }
 
 
 
     //------------------------------------------------------------
     //- Settors
 
     protected void setLineNumberReader(LineNumberReader val) {
         vLineNumberReader = val;
     }
 
 
 
     //------------------------------------------------------------
     //- Private/Protected Utility Functions
 
 
 
     //------------------------------------------------------------
     //- Public Interface Functions
 
     public String toString() {
         String result = getName();
 
         if (!getFilterNumbers().isEmpty()) {
             result += " lines" + getFilterNumbers();
         }
 
         return result;
     }
 
 
     public void backup() {
         String newName = getName() + ".orig";
         File newFile = new File(newName);
 
         if (newFile.exists() && !newFile.delete()) {
             System.err.println("Could not remove existing [" + newName + "].");
         }
 
         if (!getFile().renameTo(newFile)) {
             System.err.println("Could not rename to [" + newName + "].");
         }
     }
 
 
     public LineReader createLineReader() {
         RawLineReader rlr = new RawLineReader(getFile());
         LineReader reader = new LineReader(rlr, getFilterNumbers());
         return reader;
     }
 
 
     public void saveContent(Collection<FileLine> lines) {
         try {
             FileWriter writer = new FileWriter(getFile());
             for (FileLine fileLine : lines) {
                 String line = String.valueOf(fileLine);
                 writer.write(line);
             }
             writer.close();
         } catch (IOException ioe) {
             System.err.println("Could not write [" + getFile() + "].");
             ioe.printStackTrace();
         }
     }
 
     public void addFilterNumber(int number) {
         getFilterNumbers().add(number);
     }
 
 
     //------------------------------------------------------------
     //- Class Interface Functions
 
 
     public int compareTo(Object object) {
         int result = -1;  // Pessimistic.
 
         if (object instanceof TargetFile) {
             TargetFile other = (TargetFile) object;
 
             result = getName().compareTo(other.getName());
         }
 
         return result;
     }
 
 
     public boolean equals(Object object) {
         boolean result = (compareTo(object) == 0);
 
         return result;
     }
 
 
 
 
     //------------------------------------------------------------
     //- Inner Classes
 
 
     public class LineReader {
         private List<FileLine> vAllLines = new ArrayList<FileLine>();
         private LinkedList<FileLine> vActiveLines = new LinkedList<FileLine>();
 
 
         public LineReader(RawLineReader rlr, Collection<Integer> linesToKeep) {
             while (rlr.hasMore()) {
                 FileLine line = rlr.nextLine();
 
                 getAllLines().add(line);
 
                 Integer num = line.getNumber();
                 if (linesToKeep.isEmpty() || linesToKeep.contains(num)) {
                     getActiveLines().add(line);
                 }
             }
         }
 
         public List<FileLine> getAllLines() {
             return vAllLines;
         }
 
         protected LinkedList<FileLine> getActiveLines() {
             return vActiveLines;
         }
 
 
         public boolean hasMoreLines() {
             boolean result = !getActiveLines().isEmpty();
             return result;
         }
 
 
         public FileLine nextLine() {
             FileLine result = null;  // Pessimistic.
 
             if (hasMoreLines()) {
                 result = getActiveLines().removeFirst();
             }
 
             return result;
         }
     }
 
 
 
     //------------------------------------------------------------
     //- Main
 
 
 
 }