/*
    * 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;
  
  
  import java.io.*;
  import java.util.*;
  import java.util.regex.*;
  
  import mk.fsgrep.find.Finder;
  import mk.fsgrep.find.ScanProfile;
  import mk.fsgrep.gui.App;
  import mk.fsgrep.gui.Preferences;
  import mk.fsgrep.match.FileSearch;
  import mk.fsgrep.match.MatchResult;
  import mk.fsgrep.match.Replace;
  import mk.fsgrep.match.ReplaceControl;
  import mk.fsgrep.match.SearchFactory;
  import mk.fsgrep.util.*;
  import mk.fsgrep.util.Timer;
  import mk.fsgrep.util.output.NullOutput;
  import mk.fsgrep.util.output.OutputDestination;
  
  
  /***
   * The primary application class.
   * 
   * @author  Murali Krishnan
   *
   */
  public class Fsgrep implements Runnable {
  
      //------------------------------------------------------------
      //- Class Variables
  
      public static final ManifestProperties MANIFEST_PROPS = new ManifestProperties(Fsgrep.class);
      public static final String USAGE = TextResource.get("USAGE.txt");
      public static final String README = TextResource.get("README.txt");
      public static final String LICENSE = MANIFEST_PROPS.getLicense();
      public static final String VERSION = MANIFEST_PROPS.getProjectVersion();
      public static final String VERSION_EXTRA = TextResource.get("VERSION_EXTRA.txt");
  
      public static final Action ACTION_UNDEFINED = new Action.Undefined();
      public static final Action ACTION_SEARCH = new Action.Search();
      public static final Action ACTION_REPLACE = new Action.Replace();
      public static final Action ACTION_LISTFILES = new Action.ListFiles();
      public static final Action ACTION_RESCAN = new Action.Rescan();
  
      protected static final SearchFactory factory = SearchFactory.getInstance();
  
      /***
       * A reference to the persistent data object (singleton).
       */
      private static final PersistentData pdata = PersistentData.getInstance();
  
      public static final boolean DEBUG = Boolean.getBoolean("fsgrep.debug");
  
      protected static final Pattern RE_STRIP_EOL = Pattern.compile("(//n|//r//n|//r)//z");
  
  
      //------------------------------------------------------------
      //- Class Functions
  
  
      static public void run(Args args) {
          try {
              Fsgrep fsgrep = new Fsgrep(args);
              if (args.launchGui()) {
                  if (!DEBUG) {
                      // In debug mode, do not redirect stdout/stderr.
                      OutputRedirector.getInstance().redirect();
                  }
                  App app = new App();
                  app.launch(fsgrep);
              } else {
                  OutputDestination report = args.createReportOutput();
                  OutputDestination result = args.createResultOutput();
                 OutputDestination live = new NullOutput();
                 OutputDestination status = new NullOutput();
                 fsgrep.initialize(report,
                                   result,
                                   live,
                                   status,
                                   new TextProgressBar(report));
                 fsgrep.setPattern(args.getPattern());
                 fsgrep.setAction(ACTION_SEARCH);
 
                 fsgrep.run();
             }
         } catch (PatternSyntaxException rese) {
             System.err.println("'" + args.getPattern() + "': " + rese.getMessage());
         } catch (Throwable thr) {
             System.err.println("Fatal error.");
             thr.printStackTrace();
         }
     }
 
 
     public static String stripEol(String string) {
         String result = RE_STRIP_EOL.matcher(string).replaceAll("");
         return result;
     }
 
 
 
     //------------------------------------------------------------
     //- Instance Variables
 
     private Args _args = null;
     private Finder _finder = null;
     private Finder vBackupFinder = null;
     private List<MatchResult> fResultList = new ArrayList<MatchResult>();
     private OutputDestination _reportOutput = null;
     private OutputDestination _resultOutput = null;
     private OutputDestination _liveOutput = null;
     private OutputDestination _statusOutput = null;
     private ProgressBar _progress = new NullProgressBar();
     private ResultCounter _matchCounter = new ResultCounter();
     private ResultCounter _finishedCounter = new ResultCounter();
     private ResultCounter _remainingCounter = new ResultCounter();
     private Pattern _re = null;
     private String _pattern = "";
     private String _replacement = "";
     private boolean _aborted = false;
     private Action _action = ACTION_UNDEFINED;
     private int _totalLinesSearched = 0;
 
 
 
     //------------------------------------------------------------
     //- Constructors
 
     public Fsgrep(Args pArgs) {
         _args = pArgs;
 
         _finder = new Finder(this, new ScanProfile(pArgs.getRoot(), pArgs.getSuffix()));
     }
 
     /***
      * Only for testing.
      * 
      */
     protected Fsgrep() {
     }
 
 
     public void initialize(OutputDestination pReport, OutputDestination pResult, OutputDestination pLive, OutputDestination pStatus, ProgressBar pBar) {
         _reportOutput = pReport;
         _resultOutput = pResult;
         _liveOutput = pLive;
         _statusOutput = pStatus;
         _progress = pBar;
     }
 
 
     //------------------------------------------------------------
     //- Accessors
 
     public Args getArgs() {return _args;}
     public Finder getFinder() {return _finder;}
     public List<MatchResult> getResultList() {return fResultList;}
     public OutputDestination getReportOutput() {return _reportOutput;}
     public OutputDestination getResultOutput() {return _resultOutput;}
     public OutputDestination getLiveOutput() {return _liveOutput;}
     public OutputDestination getStatusOutput() {return _statusOutput;}
     protected ProgressBar getProgress() {return _progress;}
     public ResultCounter getMatchCounter() {return _matchCounter;}
     public ResultCounter getRemainingCounter() {return _remainingCounter;}
     public ResultCounter getFinishedCounter() {return _finishedCounter;}
     public Pattern getRE() {return _re;}
     public String getPattern() {return _pattern;}
     public String getReplacement() {return _replacement;}
     public boolean isAborted() {return _aborted;}
     public Action getAction() {return _action;}
     protected int totalLinesSearched() {return _totalLinesSearched;}
 
     protected Finder getBackupFinder() {
         return vBackupFinder;
     }
 
 
 
     //------------------------------------------------------------
     //- Settors
 
     public void setLiveOutput(OutputDestination val) {_liveOutput=val;}
     public void setMatchCounter(ResultCounter val) {_matchCounter=val;}
     public void setRemainingCounter(ResultCounter val) {_remainingCounter=val;}
     public void setFinishedCounter(ResultCounter val) {_finishedCounter=val;}
 
     public void setFinder(Finder val) {
         _finder=val;
     }
 
     protected void setRE(Pattern val) {_re=val;}
     public void setReplacement(String val) {_replacement=val;}
     public void setAborted(boolean val) {_aborted=val;}
     protected void totalLinesSearched(int val) {_totalLinesSearched=val;}
 
     protected void setBackupFinder(Finder val) {
         vBackupFinder = val;
     }
 
 
     //------------------------------------------------------------
     //- Private/Protected Utility Functions
 
     public void setAction(Action val) {
         val.setModel(this);
 
         _action = val;
     }
 
 
     public boolean getAlwaysRescan() {
         boolean result = pdata.getBooleanProperty(Preferences.KEY_RESCAN);
 
         return result;
     }
 
 
     protected void search() {
         int lineCount = 0;
         Iterator iterator = getFinder().getFileList().iterator();
         while (!isAborted() && iterator.hasNext()) {
             TargetFile file = (TargetFile) iterator.next();
             FileSearch fileSearch = factory.create(file.getSuffix(), getArgs());
             fileSearch.initialize(getRE(), file, this);
 
             // If we just want the list of files, then we do not care how
             // many matches there are within a file.  Stop searching the
             // file after the fist match to improve performance.
             if (getArgs().isListFileMatches()) {
                 fileSearch.stopAfterFirstMatch();
             }
 
             fileSearch.run();
             lineCount += fileSearch.getLinesSearched();
         }
 
         getProgress().finish();
         totalLinesSearched(lineCount);
     }
 
 
     protected void replace() {
         int lineCount = 0;
         ReplaceControl control = new ReplaceControl(getRE(), getReplacement());
         control.setReplaceCount(getMatchCounter());
 
         Iterator iterator = getFinder().getFileList().iterator();
         while (control.getDoContinue() && iterator.hasNext()) {
             TargetFile file = (TargetFile) iterator.next();
             Replace replace = new Replace(control, file);
             replace.run();
 
             finishFile(null);
         }
         setAborted(iterator.hasNext());
 
         getProgress().finish();
         totalLinesSearched(lineCount);
     }
 
 
     protected void searchForPattern() {
             prepare();
 
             if (getArgs().isSearchFileNames()) {
                 getStatusOutput().print("Applying the pattern to filenames ...");
             } else {
                 getStatusOutput().print("Searching for matches in files ...");
             }
 
             getProgress().initialize(getFinder().getFileList().size());
 
             Timer timer = new Timer();
             search();
             timer.stop();
 
             if (getArgs().isListFileMatches()) {
                 showFilelistResult();
             } else {
                 showMatchResult();
             }
 
             showResult(timer);
     }
 
 
     protected void replacePattern() {
         prepare();
 
         getStatusOutput().print("Searching for matches in files ...");
 
         getProgress().initialize(getFinder().getFileList().size());
 
         Timer timer = new Timer();
         replace();
         timer.stop();
 
         showResult(timer);
     }
 
 
     protected void showMatchResult()  {
         if (!getResultList().isEmpty()) {
             for (MatchResult result : getResultList()) {
                 getResultOutput().print(result);
             }
 
             getResultOutput().print(MatchResult.SEPARATOR);
             getResultOutput().flush();
         }
 
         // Report how many matches there were and the total number of lines
         // searched.
         {
             StringBuffer buffer = new StringBuffer();
             buffer.append(getMatchCounter().getValue()).append(" matches");
             if (totalLinesSearched() > 0) {
                 buffer.append("; ")
                     .append(totalLinesSearched())
                     .append(" total lines searched");
             }
             buffer.append(".");
             getReportOutput().println(buffer);
         }
     }
 
 
     protected List<String> getResultFilelist()  {
         List<String> result = new ArrayList<String>();
         for (MatchResult match : getResultList()) {
             result.add(match.getFilename());
         }
 
         if (getArgs().isListFilesWithoutMatch()) {
             // If we want non-matches, then we do the difference calculation.
             List<String> exclusions = result;
             result = new ArrayList<String>();
 
             for (TargetFile file : getFinder().getFileList()) {
                 String candidate = file.getName();
 
                 if (!exclusions.contains(candidate)) {
                     result.add(candidate);
                 }
             }
         }
 
         return result;
     }
 
 
     protected void showFilelistResult()  {
         List<String> results = getResultFilelist();
 
         if (!results.isEmpty()) {
             getReportOutput().print(MatchResult.SEPARATOR);
 
             for (String result : results) {
                 getResultOutput().println(result);
             }
 
             getReportOutput().print(MatchResult.SEPARATOR);
             getResultOutput().flush();
         }
 
         String resultsTag = getArgs().isListFilesWithoutMatch() ?
             " files did not contain matches." :
             " files contained matches.";
         getReportOutput().println(results.size() + resultsTag);
     }
 
 
     protected void showResult(Timer timer)  {
         long total = timer.getTotal();
         int count = getFinder().getFileList().size();
         double avg = timer.findAverage(count);
 
         getReportOutput().println("Search time: " + total + " ms, " +
                                   count + " files, " + avg + " ms per file.");
 
         // printMemory();
     }
 
 
     protected void printMemory() {
         Runtime runtime = Runtime.getRuntime();
 
         runtime.gc();
 
         long total = runtime.totalMemory() / 1024;
         long free = runtime.freeMemory() / 1024;
         long used = (total - free);
 
         System.out.println("Memory <used,free> = <" + used + "," + free + ">");
     }
 
 
     protected void prepare() {
         fResultList = new ArrayList<MatchResult>();
 
         getMatchCounter().reset();
         getFinishedCounter().reset();
 
         if (getFinder().getFileList().isEmpty() || getAlwaysRescan()) {
             getRemainingCounter().reset();
             getFinder().scan();
         }
         getRemainingCounter().setValue(getFinder().getFileCount().getValue());
     }
 
 
     protected void listFiles() {
         prepare();
 
         getReportOutput().println("Found " + getFinder().getFileList().size() +
                                   " files.");
         getStatusOutput().print("Listing files ...");
 
         for (TargetFile targetFile : getFinder().getFileList()) {
             String result = String.valueOf(targetFile);
             getResultOutput().println(result);
             getLiveOutput().println(result);
         }
 
         getResultOutput().flush();
     }
 
 
     protected int getMatchFlag() {
         int result = getArgs().isCaseSensitive() ?
             0 : Pattern.CASE_INSENSITIVE;
 
         return result;
     }
 
 
 
     //------------------------------------------------------------
     //- Public Interface Functions
 
     public String toString() {
         String result = "Fsgrep [" + getFinder().toProfileString() + ", \"" + getPattern() + "\"]";
 
         return result;
     }
 
     public void run() {
         setAborted(false);
         getReportOutput().println(this);
 
         getAction().execute();
         restoreFinder();
     }
 
     public void setPattern(String pPattern) {
         _pattern = pPattern;
 
         setRE(Pattern.compile(pPattern, getMatchFlag()));
     }
 
 
     public synchronized void finishFile(FileSearch fileSearch) {
         if ((fileSearch != null) && (fileSearch.getResults() != null)) {
             getResultList().add(fileSearch.getResults());
             getMatchCounter().increment(fileSearch.getCount());
             getLiveOutput().print(fileSearch.getResults());
         }
 
         getFinishedCounter().increment();
         getRemainingCounter().decrement();
         getProgress().update();
     }
 
 
     public boolean isActionSearch() {
         boolean result = getAction().isSearch();
 
         return result;
     }
 
 
     public void useTransientFinder(Finder pFinder) {
         setBackupFinder(getFinder());
         setFinder(pFinder);
     }
 
 
     public void restoreFinder() {
         if (getBackupFinder() != null) {
             setFinder(getBackupFinder());
             setBackupFinder(null);
         }
     }
 
 
     //------------------------------------------------------------
     //- Class Interface Functions
 
 
 
     //------------------------------------------------------------
     //- Inner Classes
 
 
 
     //------------------------------------------------------------
     //- Main
 
     static public void main(String[] cmdLineArgs) {
         Args args = new Args(cmdLineArgs);
 
         if (args.getShowUsage()) {
             System.out.println(USAGE);
         } else if (args.getShowVersion()) {
             System.out.println("fsgrep (file system grep) " + VERSION + ", " + MANIFEST_PROPS.getBuildTime());
             System.out.println();
             System.out.println(VERSION_EXTRA);
         } else {
             File root = new File(args.getRoot());
             if (root.isDirectory()) {
                 run(args);
             } else {
                 System.err.println("No directory [" + args.getRoot() + "].");
             }
         }
     }
 
 
 }