/*
    * Copyright 2007-2011 smartics, Kronseder & Reiner GmbH
    *
    * 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.
   */
  package de.smartics.exceptions.cli;
  
  import java.io.BufferedWriter;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.util.List;
  import java.util.Locale;
  import java.util.ResourceBundle;
  
  import javax.xml.stream.XMLStreamWriter;
  
  import org.apache.commons.cli.CommandLine;
  import org.apache.commons.cli.CommandLineParser;
  import org.apache.commons.cli.HelpFormatter;
  import org.apache.commons.cli.OptionBuilder;
  import org.apache.commons.cli.Options;
  import org.apache.commons.cli.ParseException;
  import org.apache.commons.cli.PosixParser;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.analysis.javadoc.Filter;
  import de.smartics.analysis.javadoc.filter.ImplementsInterfaceFilter;
  import de.smartics.analysis.javadoc.util.StringFunction;
  import de.smartics.exceptions.core.Code;
  import de.smartics.report.ReportException;
  import de.smartics.report.conf.DefaultProjectConfiguration;
  import de.smartics.report.conf.ProjectConfiguration;
  import de.smartics.report.generator.AbstractXmlReportGenerator;
  import de.smartics.report.launch.ReportLauncher;
  
  /**
   * Runs the report generator.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public class Main
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The name of the project to collect information for.
     * <p>
     * The value of this constant is {@value}.
     */
    public static final String PROJECT_NAME = "project-name";
  
    /**
     * The name of the report file to write.
     * <p>
     * The value of this constant is {@value}.
     */
    public static final String REPORT_FILE = "report-file";
  
    /**
     * The class name of the report generator instance to use.
     * <p>
     * The value of this constant is {@value}.
     */
    public static final String REPORT_GENERATOR = "report-generator";
  
    /**
     * The encoding of the report documentation.
     * <p>
     * The value of this constant is {@value}.
     */
    public static final String REPORT_ENCODING = "report-encoding";
  
    /**
     * The semicolon separated excluded directories. Use Ant syntax.
     * <p>
     * The value of this constant is {@value}.
     */
    public static final String REPORT_EXCLUDES = "report-excludes";
  
    /**
     * The semicolon separated included directories. Use Ant syntax.
     * <p>
     * The value of this constant is {@value}.
    */
   public static final String REPORT_INCLUDES = "report-includes";
 
   /**
    * The encoding of the Java source files.
    * <p>
    * The value of this constant is {@value}.
    */
   public static final String JAVA_SOURCE_ENCODING = "java-source-encoding";
 
   /**
    * The semicolon separated source root directories.
    * <p>
    * The value of this constant is {@value}.
    */
   public static final String JAVA_SOURCE_PATH = "java-source-path";
 
   /**
    * The semicolon separated class root directories. If this is set, the default
    * class path specified by <code>java.class.path</code> will not be used. The
    * default class path is used if this property is not specified.
    * <p>
    * The value of this constant is {@value}.
    */
   public static final String JAVA_CLASS_PATH = "java-class-path";
 
   /**
    * The link reference to the CSS file to add to the head element of the
    * generated HTML document.
    * <p>
    * The value of this constant is {@value}.
    */
   public static final String CSS_FILE = "css-file";
 
   // --- members --------------------------------------------------------------
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    */
   public Main()
   {
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Runs with system properties. See constants in this class for options.
    *
    * @throws ReportException ReportException on any problem generating the
    *           report.
    * @throws ParseException
    * @see de.smartics.exceptions.report.Main#run(de.smartics.exceptions.report.core.ExceptionCodeProjectConfiguration)
    */
   public int run(final String... args) throws ReportException
   {
     final Options options = createOptions();
     try
     {
       final CommandLine commandLine = createCommandLine(options, args);
       final ProjectConfiguration<XMLStreamWriter> config =
           createConfig(commandLine);
       run(config);
       System.out.println("Report '" + commandLine.getOptionValue(REPORT_FILE) // NOPMD
                          + "' written successfully.");
       return 0;
     }
     catch (final ParseException e)
     {
       final HelpFormatter formatter = new HelpFormatter();
       System.err.println(e.getLocalizedMessage()); // NOPMD
       formatter.printHelp("java " + getClass().getName(), options);
       return -1;
     }
   }
 
   /**
    * Creates the report configuration to control the report generation from the
    * information provided by the command line.
    *
    * @param commandLine the user's command line arguments to control the
    *          generation of the report.
    * @return the project configuration to control the report generation.
    */
   private static ProjectConfiguration<XMLStreamWriter> createConfig(
       final CommandLine commandLine)
   {
     final List<String> classRootDirectoryNames =
         readClassRootDirectoryNames(commandLine);
     final String sourcePath = commandLine.getOptionValue(JAVA_SOURCE_PATH);
     final List<String> sourceRootDirectoryNames =
         StringFunction.split(sourcePath, ";");
 
     final String includesString =
         commandLine.getOptionValue(REPORT_INCLUDES, "**");
     final List<String> includes = StringFunction.split(includesString, ",");
     final String excludesString = commandLine.getOptionValue(REPORT_EXCLUDES);
     final List<String> excludes = StringFunction.split(excludesString, ",");
 
     final DefaultProjectConfiguration.Builder<XMLStreamWriter> builder =
         new DefaultProjectConfiguration.Builder<XMLStreamWriter>(
             commandLine.getOptionValue(PROJECT_NAME));
 
     builder.setIncludes(includes);
     builder.setExcludes(excludes);
     builder.setSourceEncoding(commandLine.getOptionValue(JAVA_SOURCE_ENCODING,
         "UTF-8"));
     builder.setClassRootDirectoryNames(classRootDirectoryNames);
     builder.setSourceRootDirectoryNames(sourceRootDirectoryNames);
 
     builder.setReportEncoding(commandLine.getOptionValue(REPORT_ENCODING,
         "UTF-8"));
     builder.setReporter(commandLine.getOptionValue(REPORT_GENERATOR,
         "de.smartics.exceptions.report.generator.HtmlReportGenerator"));
     builder.setReport(commandLine.getOptionValue(REPORT_FILE));
     builder.setStyleSheet(commandLine.getOptionValue(CSS_FILE));
 
     final Filter filter = new ImplementsInterfaceFilter(Code.class);
     builder.setFilter(filter);
 
     final ResourceBundle bundle =
         ResourceBundle.getBundle(
             "de/smartics/exceptions/report/ExceptionCodeReportBundle",
             Locale.ENGLISH, Main.class.getClassLoader()); // NOPMD
     builder.setBundle(bundle);
 
     final ProjectConfiguration<XMLStreamWriter> config = builder.build();
     return config;
   }
 
   /**
    * Reads the collection of class path root directories.
    *
    * @return the collection of class path root directories.
    */
   private static List<String> readClassRootDirectoryNames(
       final CommandLine commandLine)
   {
     String classPath = commandLine.getOptionValue(JAVA_CLASS_PATH);
     if (StringUtils.isBlank(classPath))
     {
       classPath = System.getProperty("java.class.path");
     }
     final List<String> classRootDirectoryNames =
         StringFunction.split(classPath, ";");
     return classRootDirectoryNames;
   }
 
   /**
    * Delegates call to {@link #run(ProjectConfiguration,XMLStreamWriter)} .
    *
    * @param config the configuration to control the discovery process.
    * @throws ReportException on any problem generating the report.
    * @see #run(ProjectConfiguration,XMLStreamWriter)
    */
   public void run(final ProjectConfiguration<XMLStreamWriter> config)
     throws ReportException
   {
     final String reportEncoding = config.getReportEncoding();
     final String report = config.getReport();
 
     Writer writer = null;
     try
     {
       writer =
           new BufferedWriter(new OutputStreamWriter(
               new FileOutputStream(report), reportEncoding));
       final XMLStreamWriter output =
           AbstractXmlReportGenerator.createOutput(writer);
       run(config, output);
     }
     catch (final ReportException e) // NOPMD
     {
       throw e;
     }
     catch (final Exception e)
     {
       throw new ReportException(e);
     }
     finally
     {
       IOUtils.closeQuietly(writer);
     }
   }
 
   /**
    * Runs the reporting with the given configuration and writer.
    *
    * @param configuration the configuration to control the discovery process.
    * @param output the writer to write to. This overrules the report file in the
    *          configuration. If the writer is <code>null</code> the report file
    *          is required to be set.
    * @throws ReportException on any problem generating the report.
    */
   public void run(final ProjectConfiguration<XMLStreamWriter> configuration,
       final XMLStreamWriter output) throws ReportException
   {
     final ReportLauncher<XMLStreamWriter> launcher =
         new ReportLauncher<XMLStreamWriter>("exceptioncodes-cli");
     launcher.launch(configuration, output);
   }
 
   // ... helper ...............................................................
 
   /**
    * Parses the command line arguments and returns the parsed result.
    *
    * @param args the command line arguments to parse.
    * @return the command line information.
    * @throws ParseException if the command line cannot be parsed.
    */
   private static CommandLine createCommandLine(final Options options,
       final String[] args) throws ParseException
   {
     final CommandLineParser parser = new PosixParser();
     final CommandLine cmd = parser.parse(options, args);
     return cmd;
   }
 
   /**
    * Creates the options for the CLI.
    *
    * @return the requested options.
    */
   private static Options createOptions()
   {
     final Options options = new Options();
 
     options
         .addOption(OptionBuilder.withLongOpt(JAVA_SOURCE_ENCODING)
             .withArgName("encoding").hasArg()
             .withDescription("the encoding of the Java source files.")
             .create("se"));
     options.addOption(OptionBuilder.withLongOpt(JAVA_SOURCE_PATH)
         .withArgName("path1;path2").hasArg()
         .withDescription("the semicolon separated source root directories.")
         .isRequired().create("path"));
     options.addOption(OptionBuilder.withLongOpt(JAVA_CLASS_PATH)
         .withArgName("path1;path2").hasArg()
         .withDescription("the semicolon separated classpath root directories.")
         .create("cp"));
     options.addOption(OptionBuilder
         .withLongOpt(REPORT_INCLUDES)
         .withArgName("path;path")
         .hasArg()
         .withDescription(
             "the semicolon separated included directories. Use Ant syntax.")
         .create("i"));
     options.addOption(OptionBuilder
         .withLongOpt(REPORT_EXCLUDES)
         .withArgName("path;path")
         .hasArg()
         .withDescription(
             "the semicolon separated excluded directories. Use Ant syntax.")
         .create("e"));
     options.addOption(OptionBuilder.withLongOpt(REPORT_ENCODING)
         .withArgName("encoding").hasArg()
         .withDescription("the encoding of the report documentation.")
         .create("c"));
     options.addOption(OptionBuilder
         .withLongOpt(REPORT_GENERATOR)
         .withArgName("class")
         .hasArg()
         .withDescription(
             "the class name of the report generator instance to use.")
         .create("g"));
     options.addOption(OptionBuilder.withLongOpt(REPORT_FILE)
         .withArgName("file").hasArg()
         .withDescription("the name of the report file to write.").isRequired()
         .create("f"));
     options.addOption(OptionBuilder.withLongOpt(PROJECT_NAME)
         .withArgName("project-name").hasArg()
         .withDescription("the name of the project to collect information for.")
         .isRequired().create("p"));
     options
         .addOption(OptionBuilder
             .withLongOpt(CSS_FILE)
             .withArgName("css-file")
             .hasArg()
             .withDescription(
                 "the link reference to the CSS file to add to the head element of the generated HTML document.")
             .isRequired().create("s"));
     return options;
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * Launches the program.
    *
    * @param args the program arguments.
    * @throws IOException on any problem reading from or writing to streams.
    * @throws ReportException on any problem generating the report.
    */
   public static void main(final String... args) throws Exception,
     ReportException
   {
     final Main main = new Main();
     final int returnCode = main.run(args);
     System.exit(returnCode); // NOPMD
   }
 }