/*
    * 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.*;
  import java.util.regex.*;
  
  import mk.fsgrep.util.output.OutputDestination;
  
  
  /***
   * A utility for launching an external editor on a match file.
   * 
   * @author  Murali Krishnan
   *
   */
  public abstract class ExternalEditor {
  
      //------------------------------------------------------------
      //- Class Variables
  
      protected static ExternalEditor _instance = null;
  
      protected static ExternalEditor UNDEFINED = new Undefined();
  
      public static final String PERSISTENT_MAP_KEY = "external_editor";
  
      private static final PersistentData pdata = PersistentData.getInstance();
  
      public static final Pattern RE_FILE_NAME = Pattern.compile("%f");
      public static final Pattern RE_LINE_NUM = Pattern.compile("%n");
      public static final Pattern P_BACKSLASH = Pattern.compile("////");
      public static final Pattern P_DOLLAR = Pattern.compile("//$");
  
  
      //------------------------------------------------------------
      //- Class Functions
  
      public static synchronized ExternalEditor getInstance() {
          ExternalEditor result = UNDEFINED;
  
          if (_instance == null) {
              String definition = lookupDefinition();
              if (!"".equals(definition)) {
                  _instance = new Defined(definition);
                  result = _instance;
              }
          } else {
              result = _instance;
          }
  
          return result;
      }
  
  
      public static void reset() {
          _instance = null;
      }
  
  
      protected static String lookupDefinition() {
          String result = "";  // Pessimistic.
  
          String candidate = pdata.getProperty(PERSISTENT_MAP_KEY);
          if ((candidate != null)) {
              result = candidate;
          }
  
          return result;
      }
  
  
      protected static String[] createCmdArray(String cmd) {
          List<String> list = new ArrayList<String>();
  //         StringTokenizer tokenizer = new StringTokenizer(cmd, " ");
 //         while (tokenizer.hasMoreTokens()) {
 //             list.add(tokenizer.nextToken());
 //         }
         boolean inDouble = false;
         boolean inSingle = false;
         StringBuffer buffer = new StringBuffer();
         char[] charray = cmd.toCharArray();
         for (char ch : charray) {
             if (inDouble) {
                 if (ch == '\"') {
                     inDouble = false;
                 } else {
                     buffer.append(ch);
                 }
             } else if (inSingle) {
                 if (ch == '\'') {
                     inSingle = false;
                 } else {
                     buffer.append(ch);
                 }
             } else {
                 if (ch == '\"') {
                     inDouble = true;
                 } else if (ch == '\'') {
                     inSingle = true;
                 } else if (Character.isWhitespace(ch)) {
                     if (buffer.length() > 0) {
                         list.add(buffer.toString());
                         buffer.delete(0, buffer.length());
                     }
                 } else {
                     buffer.append(ch);
                 }
             }
         }
 
         if (buffer.length() > 0) {
             list.add(buffer.toString());
         }
 
         String[] result = list.toArray(new String[0]);
 
         return result;
     }
 
 
     //------------------------------------------------------------
     //- Instance Variables
 
     private String _spec = "";
 
 
     //------------------------------------------------------------
     //- Constructors
 
     ExternalEditor(String string) {
         _spec = string;
     }
 
 
     //------------------------------------------------------------
     //- Accessors
 
     protected String getSpec() {return _spec;}
 
 
     //------------------------------------------------------------
     //- Settors
 
 
 
     //------------------------------------------------------------
     //- Private/Protected Utility Functions
 
     protected String createCommand(String filename, String linenum) {
         String result = getSpec();
 
         // If the filename pattern occurs in the spec, then replace it with
         // the filename.  Otherwise append the filename.
         Matcher matcher = RE_FILE_NAME.matcher(getSpec());
         if (matcher.find()) {
             // Note that the replacement string processes '\' and '$', so
             // these must be escaped.
             String processed = P_BACKSLASH.matcher(filename).replaceAll("////////");
             processed = P_DOLLAR.matcher(processed).replaceAll("//////$");
             result = matcher.replaceAll(processed);
         } else {
             result += " " + filename;
         }
 
         // Replace the linenumber pattern with the linenumber.
         result = RE_LINE_NUM.matcher(result).replaceAll(linenum);
 
         return result;
     }
 
 
     //------------------------------------------------------------
     //- Public Interface Functions
 
     public String toString() {
         String result = "ExternalEditor[" + (isDefined()?getSpec():"UNDEFINED") + "]";
 
         return result;
     }
 
 
     public void launch(String filename, String linenum, OutputDestination pStatus, OutputDestination pError) {
         System.err.println("Launch capability is undefined.");
     }
 
 
     //------------------------------------------------------------
     //- Class Interface Functions
 
     public boolean isDefined() {return true;}
 
 
     //------------------------------------------------------------
     //- Inner Classes
 
     static class Undefined extends ExternalEditor {
         Undefined() {super("");}
         public boolean isDefined() {return false;}
     }
 
     static class Defined extends ExternalEditor {
         Defined(String string) {super(string);}
 
 
         public void launch(String filename, String linenum, OutputDestination pStatus, OutputDestination pError) {
             String cmd = createCommand(filename, linenum);
             String[] cmdarray = createCmdArray(cmd);
             // for (int i = 0; i < cmdarray.length; i++) {
             //     String arg = cmdarray[i];
             //     System.out.println("[" + arg + "]");
             // }
             pStatus.print("Launching [" + cmd + "]");
             Runtime runtime = Runtime.getRuntime();
             try {
                 //noinspection UnusedDeclaration
                 Process process = runtime.exec(cmdarray);
                 // process.waitFor();
             } catch (IOException ioe) {
                 System.err.println("Could not exec [" + cmd + "].");
                 ioe.printStackTrace();
                 pError.print("Could not exec:\n" + cmd);
             }
         }
     }
 
 
     //------------------------------------------------------------
     //- Main
 
 
 
 }