/*
    * Copyright 2007-2013 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.maven.exceptions;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Locale;
  import java.util.ResourceBundle;
  
  import org.apache.commons.lang.LocaleUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.maven.artifact.DependencyResolutionRequiredException;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.reporting.MavenReportException;
  
  import de.smartics.exceptions.report.ReportBuilder;
  import de.smartics.exceptions.report.ReportConfiguration;
  import de.smartics.exceptions.report.data.InMemoryExceptionCodesReport;
  import de.smartics.exceptions.report.data.ProjectConfiguration;
  import de.smartics.exceptions.report.data.ReportProblem;
  import de.smartics.exceptions.report.generator.ReportGenerator;
  import de.smartics.exceptions.report.utils.StringFunction;
  import de.smartics.maven.exceptions.conf.ConfigUtils;
  import de.smartics.maven.exceptions.conf.DefaultProjectConfiguration;
  import de.smartics.maven.exceptions.runtime.ProjectClassLoader;
  import de.smartics.maven.io.MojoIoUtils;
  import de.smartics.maven.util.LoggingUtils;
  import de.smartics.maven.util.PathUtils;
  
  /**
   * Base implementation to generate SDoc documentation files.
   */
  public abstract class AbstractSdocCodeMojo extends AbstractMojo // NOPMD
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ... Mojo infrastructure ..................................................
  
    /**
     * The Maven project.
     *
     * @parameter expression="${project}"
     * @required
     * @readonly
     * @since 1.0
     */
    protected MavenProject project;
  
    /**
     * The plugin's dependencies to build the classpath for tools to be called.
     *
     * @parameter expression="${plugin.artifacts}"
     * @required
     * @readonly
     */
    @SuppressWarnings("rawtypes")
    // NOPMD
    protected ArrayList pluginArtifacts; // NOPMD
  
    /**
     * A simple flag to skip the generation of the XML files. If set on the
     * command line use <code>-Dsdoccode.skip</code>.
     *
     * @parameter expression="${sdoccode.skip}" default-value="false"
     * @since 1.0
     */
    protected boolean skip;
  
    /**
     * Specifies the log level used for this plugin.
     * <p>
     * Allowed values are <code>SEVERE</code>, <code>WARNING</code>,
     * <code>INFO</code> and <code>FINEST</code>.
     * </p>
     *
     * @parameter expression="${exceptioncodes.logLevel}"
     * @since 1.0
    */
   private String logLevel;
 
   /**
    * The locale to use regardless of the report. This should be set to the
    * locale the Javadoc comment is written in. If not set, the Maven provided
    * locale is used.
    *
    * @parameter expression="${exceptioncodes.locale}"
    * @since 1.0
    */
   protected String locale;
 
   // ... core information .....................................................
 
   // ... sources
 
   /**
    * Specifies additional root directories of source files to consider. Please
    * note that source file archives found at the same location as the class file
    * archives are automatically visible. The source archive is required to have
    * the suffix <code>-sources</code> in front of the extension and only jar-
    * and zip-archives are supported.
    *
    * @parameter expression="${exceptioncodes.additionalSources}"
    * @since 1.0
    */
   private String additionalSources;
 
   /**
    * Specifies the encoding the sources will be read.
    *
    * @parameter expression="${project.build.sourceEncoding}"
    *            default-value="UTF-8"
    * @since 1.0
    */
   private String sourceEncoding;
 
   /**
    * Specifies the Java version of the sources.
    *
    * @parameter expression="${exceptioncodes.build.sourceVersion}"
    *            default-value="1.5"
    * @since 1.0
    */
   private String sourceVersion;
 
   /**
    * Specifies the names filter of the source and class files to be included in
    * the reports. The path starts at the source path root, not at the project
    * root.
    *
    * @parameter expression="${exceptioncodes.includes}"
    * @since 1.0
    */
   @SuppressWarnings("rawtypes")
   private ArrayList includes; // NOPMD
 
   /**
    * Specifies the names filter of the source and class files to be excluded
    * from the reports. The path starts at the source path root, not at the
    * project root.
    *
    * @parameter expression="${exceptioncodes.excludes}"
    * @since 1.0
    */
   @SuppressWarnings("rawtypes")
   private ArrayList excludes; // NOPMD
 
   // ... sources
 
   /**
    * Specifies the root directory to write the report files to.
    *
    * @parameter expression="${project.build.directory}/sdoc-export"
    * @since 1.0
    */
   private String outputDirectory;
 
   /**
    * The file to write to.
    *
    * @since 1.0
    */
   protected File output;
 
   /**
    * Specifies the encoding the reports will be written.
    *
    * @parameter expression="${project.reporting.outputEncoding}"
    *            default-value="UTF-8"
    * @since 1.0
    */
   private String reportEncoding;
 
   /**
    * Specifies the name of the report generator instance. This class has to
    * implement <code>de.smartics.exceptions.report.ReportGenerator</code>.<br/>
    * Currently one implementation is provided, which is the default.
    *
    * @parameter expression="${exceptioncodes.report.generator}" default-value=
    *            "de.smartics.maven.exceptions.sdoc.SdocCodeReportGenerator"
    * @since 1.0
    */
   private String reportGenerator;
 
   /**
    * Specifies the mapper class that allows finding the the bundle associated
    * with a given code. The referenced class requires to implement
    * <code>de.smartics.messages.core.DefaultLocationBundleMapper</code>.
    *
    * @parameter default-value=
    *            "de.smartics.messages.core.DefaultLocationBundleMapper"
    * @since 1.0
    */
   private String codeBundleMapper;
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the maven project.
    *
    * @return the maven project.
    */
   public MavenProject getProject()
   {
     return project;
   }
 
   /**
    * Sets the maven project.
    *
    * @param project the maven project.
    */
   public void setProject(final MavenProject project)
   {
     this.project = project;
   }
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    */
   public void execute() throws MojoExecutionException, MojoFailureException
   {
     if (skip)
     {
       getLog().info("Skipping sdoc exception code collection since skip=true.");
       return;
     }
 
     if (canBuild())
     {
       init();
       final Locale locale = determineLocale();
 
       try
       {
         final ProjectConfiguration<File> projectConfig =
             createProjectConfiguration(locale, output);
         final ReportConfiguration reportConfig =
             createReportConfiguration(projectConfig);
 
         final ReportBuilder builder = ReportBuilder.create(reportConfig);
         final InMemoryExceptionCodesReport report =
             new InMemoryExceptionCodesReport();
         builder.reportTo(report);
 
         if (report.hasProblems())
         {
           final String message = toString(report.getProblems());
           getLog().error(message);
           throw new MavenReportException(
               "Problems encountered while generating report.\n"
                   + " Please refer to error log for details.");
         }
 
         final ReportGenerator<File> generator =
             projectConfig.getReporterInstance();
         generator.setOutput(output);
         generator.writeReport(projectConfig, report);
 
         handleGeneratedDocuments();
       }
       catch (final Exception e)
       {
         throw new MojoExecutionException(
             "Cannot generate code export for projectdoc.", e);
       }
     }
     else
     {
       getLog().debug(
           "Skipping sdoccode since no classes are provided by this project.");
     }
   }
 
   private static String toString(final List<ReportProblem> problems)
   {
     final StringBuilder buffer = new StringBuilder(512);
 
     for (final ReportProblem problem : problems)
     {
       buffer.append(problem).append('\n');
     }
 
     return buffer.toString();
   }
 
   /**
    * Handles the generated documents.
    *
    * @throws MojoExecutionException if the execution encounters a problem.
    * @throws MojoFailureException if the mojo fails.
    */
   protected abstract void handleGeneratedDocuments()
     throws MojoExecutionException, MojoFailureException;
 
   @SuppressWarnings("unchecked")
   // NOPMD
   private void init() throws MojoExecutionException
   {
     LoggingUtils.configureLogger(getLog(), logLevel);
     if (includes.isEmpty())
     {
       includes.add("**");
     }
 
     if (StringUtils.isBlank(codeBundleMapper))
     {
       throw new IllegalArgumentException(
           "No code bundle mapper class provided."
               + " Please specify one by the mojo parameter 'codeBundleMapper'.");
     }
 
     this.output = MojoIoUtils.provideMojoDirectory(outputDirectory);
   }
 
   /**
    * Determines the locale to use. The plugin allows the user to override the
    * locale provided by Maven.
    *
    * @return the locale to use for this report.
    */
   private Locale determineLocale()
   {
     return StringUtils.isNotBlank(this.locale) ? LocaleUtils
         .toLocale(this.locale) : Locale.getDefault();
   }
 
   @SuppressWarnings("unchecked")
   private boolean canBuild()
   {
     final String packaging = project.getPackaging();
     return !("pom".equals(packaging) || !PathUtils.exists(project
         .getCompileSourceRoots()));
   }
 
   @SuppressWarnings("unchecked")
   private ProjectConfiguration<File> createProjectConfiguration(
       final Locale locale, final File outputDir)
     throws DependencyResolutionRequiredException
   {
     final List<String> classRootDirectoryNames =
         project.getCompileClasspathElements();
 
     final List<String> sourceRootDirectoryNames = new ArrayList<String>();
     sourceRootDirectoryNames.addAll(StringFunction.split(
         this.additionalSources, ","));
     sourceRootDirectoryNames.addAll(project.getCompileSourceRoots());
     sourceRootDirectoryNames.addAll(ConfigUtils
         .discoverSourceJars(classRootDirectoryNames));
     final List<String> toolClassPath = PathUtils.toClassPath(pluginArtifacts);
 
     final Log log = getLog();
     if (log.isDebugEnabled())
     {
       log.debug("Tool class path: " + toolClassPath);
       log.debug("Class roots    : " + classRootDirectoryNames);
       log.debug("Source roots   : " + sourceRootDirectoryNames);
     }
 
     final DefaultProjectConfiguration.Builder<File> builder =
         new DefaultProjectConfiguration.Builder<File>(project.getName());
 
     builder.setIncludes(includes);
     builder.setExcludes(excludes);
     builder.setSourceEncoding(this.sourceEncoding);
     builder.setSourceVersion(this.sourceVersion);
     builder.setToolClassPath(toolClassPath);
     builder.setClassRootDirectoryNames(classRootDirectoryNames);
     builder.setSourceRootDirectoryNames(sourceRootDirectoryNames);
     builder.setJavadocDir(null);
 
     builder.setReportEncoding(this.reportEncoding);
     builder.setReporter(this.reportGenerator);
     builder.setReport(outputDir.getAbsolutePath());
 
     final ResourceBundle bundle = getBundle(locale);
     builder.setBundle(bundle);
     builder.setBundleMapperClassName(this.codeBundleMapper);
 
     final ProjectConfiguration<File> config = builder.build();
     return config;
   }
 
   private ReportConfiguration createReportConfiguration(
       final ProjectConfiguration<File> projectConfig)
   {
     final ReportConfiguration reportConfig = new ReportConfiguration();
     reportConfig.setEncoding(this.sourceEncoding);
     final ProjectClassLoader classLoader =
         new ProjectClassLoader(Thread.currentThread().getContextClassLoader(),
             projectConfig.getClassRootDirectoryNames());
     reportConfig.setProjectClassLoader(classLoader);
     for (final String name : projectConfig.getSourceRootDirectoryNames())
     {
       final File file = new File(name);
       reportConfig.addSourceTree(file);
     }
 
     reportConfig.addIncludes(projectConfig.getIncludes());
     reportConfig.addExcludes(projectConfig.getExcludes());
 
     return reportConfig;
   }
 
   private ResourceBundle getBundle(final Locale locale)
   {
     return ResourceBundle.getBundle(getBundleName(), locale, getClass()
         .getClassLoader()); // NOPMD
   }
 
   private String getBundleName()
   {
     return "de/smartics/maven/exceptions/sdoc/SdocCodeBundle";
   }
 
   // --- object basics --------------------------------------------------------
 
 }