package net.logAnalyzer.config;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   
   import net.logAnalyzer.LogAnalyzerBatch;
   import net.logAnalyzer.utils.FilesSetReader;
   
   import org.apache.log4j.Logger;
  
  /***
   * This class is a simple container for command lines options.
   * 
   * @author KKI
   * @see net.logAnalyzer.LogAnalyzerBatch
   */
  public class StartUpOptions {
      /***
       * Class logger.
       */
      private static Logger logger = Logger.getLogger(LogAnalyzerBatch.class
              .getName());
  
      /***
       * Commands file defining commands to execute during analysis.
       */
      private File commandsFile = null;
  
      /***
       * File name of the commands file to execute during analysis.
       */
      private String commandsFilename = null;
  
      /***
       * Log file(s) to analyse.
       */
      private FilesSetReader logFiles = null;
  
      /***
       * If <tt>true</tt>, the option "-GUI" shows the GUI at the end of the
       * analysis.
       */
      private boolean optionShowGUI = false;
  
      /***
       * Directory in which to save the generated reports.
       */
      private File reportsDirectory = null;
  
      /***
       * Reports prefix used as prefix for reports files names.
       */
      private String reportsPrefix = "";
  
      /***
       * Default construtor.
       */
      public StartUpOptions() {
          super();
      }
  
      /***
       * Commands file defining commands to execute during analysis.
       * 
       * @return Returns the commandsFile.
       */
      public final File getCommandsFile() {
          return commandsFile;
      }
  
      /***
       * File name of the commands file to execute during analysis.
       * 
       * @return Returns the commandsFilename.
       */
      public final String getCommandsFilename() {
          return commandsFilename;
      }
  
      /***
       * Log files to analyse.
       * 
       * @return Returns the logFiles.
       */
      public final FilesSetReader getLogFiles() {
          return logFiles;
      }
  
      /***
       * If <tt>true</tt>, the option "-GUI" shows the GUI at the end of the
       * analysis.
       * 
       * @return Returns the optionShowGUI.
       */
      public final boolean isOptionShowGUI() {
          return optionShowGUI;
      }
  
      /***
      * Directory in which to save the generated reports.
      * 
      * @return Returns the reportsDirectory.
      */
     public final File getReportsDirectory() {
         return reportsDirectory;
     }
 
     /***
      * Reports prefix used as prefix for reports files names.
      * 
      * @return Returns the reportsPrefix.
      */
     public final String getReportsPrefix() {
         return reportsPrefix;
     }
 
     /***
      * Extracts options from the command line args array.
      * 
      * @param args
      *            Command line args array.
      */
     public final void setArgs(String[] args) {
         if (args == null || args.length < 2) {
             throw new IllegalArgumentException();
         }
         int argsOffset = 0;
         // Extracts optional args
         while (args[argsOffset] != null && args[argsOffset].length() > 0
                 && args[argsOffset].charAt(0) == '-'
                 && "-gui -reportsprefix".indexOf(args[argsOffset]) >= 0) {
             // Option -gui
             if ("-gui".equalsIgnoreCase(args[argsOffset])) {
                 optionShowGUI = true;
                 argsOffset++;
             }
             // Option -reportsprefix
             if ("-reportsprefix".equalsIgnoreCase(args[argsOffset])) {
                 argsOffset++;
                 reportsPrefix = args[argsOffset];
                 argsOffset++;
             }
         }
         // Extracts commands file name
         logger.debug("Control if the commands file exists");
         commandsFilename = args[argsOffset];
         commandsFile = new File(commandsFilename);
         if (!commandsFile.exists() || !commandsFile.canRead()) {
             System.err.println("Can't find or read the commands file ["
                     + commandsFilename + "]");
             logger.error("Can't find or read the commands file ["
                     + commandsFilename + "]");
             System.exit(1);
         }
         logger.debug("...OK [" + commandsFilename + "]");
         argsOffset++;
         // Extracts logfiles names
         if (args.length - argsOffset <= 0) {
             System.err.println("You must provide one or more files to analyze");
             logger.error("You must provide one or more files to analyze");
             System.exit(-1);
         }
         logger.debug("Control if the logfile(s) exist");
         File[] files = new File[args.length - argsOffset];
         for (int i = 0; i < files.length; i++) {
             files[i] = new File(args[argsOffset++]);
         }
         logFiles = new FilesSetReader();
         try {
             logFiles.setFiles(files);
         } catch (FileNotFoundException fnfe) {
             System.err.println("Can't find or read the log file(s)");
             logger.error("Can't find or read the log file(s)", fnfe);
             System.exit(1);
         }
         if (logger.isDebugEnabled()) {
             String msg = "...OK \n";
             for (int i = 0; i < files.length; i++) {
                 msg += "\t[" + files[i] + "]";
             }
             logger.debug(msg);
         }
         argsOffset += files.length;
         // Create the reports directory
         reportsDirectory = new File(files[files.length - 1].getAbsolutePath()
                 + ".reports");
         if (!reportsDirectory.exists()) {
             logger.debug("Create the reports directory ["
                     + reportsDirectory.getAbsolutePath() + "]");
             reportsDirectory.mkdirs();
         } else {
             logger.debug("The reports directory ["
                     + reportsDirectory.getAbsolutePath() + "] exists");
         }
     }
 }