package org.apache.maven.plugins.pdf;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you 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.

  */

 import java.io.File;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.Reader;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.lang.reflect.InvocationHandler;

 import java.lang.reflect.Method;

 import java.lang.reflect.Proxy;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Properties;

 import javax.swing.text.AttributeSet;

 import org.apache.commons.io.input.XmlStreamReader;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionException;

 import org.apache.maven.artifact.versioning.ArtifactVersion;

 import org.apache.maven.artifact.versioning.DefaultArtifactVersion;

 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;

 import org.apache.maven.artifact.versioning.VersionRange;

 import org.apache.maven.doxia.Doxia;

 import org.apache.maven.doxia.docrenderer.AbstractDocumentRenderer;

 import org.apache.maven.doxia.docrenderer.DocumentRenderer;

 import org.apache.maven.doxia.docrenderer.DocumentRendererContext;

 import org.apache.maven.doxia.docrenderer.DocumentRendererException;

 import org.apache.maven.doxia.docrenderer.pdf.PdfRenderer;

 import org.apache.maven.doxia.document.DocumentMeta;

 import org.apache.maven.doxia.document.DocumentModel;

 import org.apache.maven.doxia.document.DocumentTOCItem;

 import org.apache.maven.doxia.document.io.xpp3.DocumentXpp3Writer;

 import org.apache.maven.doxia.index.IndexEntry;

 import org.apache.maven.doxia.index.IndexingSink;

 import org.apache.maven.doxia.module.xdoc.XdocSink;

 import org.apache.maven.doxia.parser.ParseException;

 import org.apache.maven.doxia.parser.manager.ParserNotFoundException;

 import org.apache.maven.doxia.sink.Sink;

 import org.apache.maven.doxia.sink.SinkAdapter;

 import org.apache.maven.doxia.sink.SinkEventAttributeSet;

 import org.apache.maven.doxia.sink.SinkEventAttributes;

 import org.apache.maven.doxia.site.decoration.DecorationModel;

 import org.apache.maven.doxia.site.decoration.io.xpp3.DecorationXpp3Reader;

 import org.apache.maven.doxia.siterenderer.Renderer;

 import org.apache.maven.doxia.siterenderer.SiteRenderingContext;

 import org.apache.maven.doxia.tools.SiteTool;

 import org.apache.maven.doxia.tools.SiteToolException;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.model.MailingList;

 import org.apache.maven.model.ReportPlugin;

 import org.apache.maven.model.ReportSet;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.InvalidPluginException;

 import org.apache.maven.plugin.MojoExecution;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugin.PluginConfigurationException;

 import org.apache.maven.plugin.PluginManager;

 import org.apache.maven.plugin.PluginManagerException;

 import org.apache.maven.plugin.PluginNotFoundException;

 import org.apache.maven.plugin.descriptor.MojoDescriptor;

 import org.apache.maven.plugin.descriptor.PluginDescriptor;

 import org.apache.maven.plugin.version.PluginVersionNotFoundException;

 import org.apache.maven.plugin.version.PluginVersionResolutionException;

 import org.apache.maven.plugins.annotations.Component;

 import org.apache.maven.plugins.annotations.Mojo;

 import org.apache.maven.plugins.annotations.Parameter;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.project.MavenProjectBuilder;

 import org.apache.maven.project.ProjectBuildingException;

 import org.apache.maven.reporting.AbstractMavenReportRenderer;

 import org.apache.maven.reporting.MavenReport;

 import org.apache.maven.reporting.MavenReportException;

 import org.apache.maven.reporting.exec.MavenReportExecution;

 import org.apache.maven.reporting.exec.MavenReportExecutor;

 import org.apache.maven.reporting.exec.MavenReportExecutorRequest;

 import org.apache.maven.settings.Settings;

 import org.codehaus.plexus.PlexusConstants;

 import org.codehaus.plexus.PlexusContainer;

 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;

 import org.codehaus.plexus.context.Context;

 import org.codehaus.plexus.context.ContextException;

 import org.codehaus.plexus.i18n.I18N;

 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.PathTool;

 import org.codehaus.plexus.util.ReaderFactory;

 import org.codehaus.plexus.util.StringUtils;

 import org.codehaus.plexus.util.WriterFactory;

 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

 /**

  * Generates a PDF document for a project.

  *

  * @author ltheussl

  * @version $Id: PdfMojo.java 1642369 2014-11-28 21:54:06Z hboutemy $

  */

 @Mojo( name = "pdf", threadSafe = true )

 public class PdfMojo

     extends AbstractMojo implements Contextualizable

 {

     /**

      * The vm line separator

      */

     private static final String EOL = System.getProperty( "line.separator" );

     // ----------------------------------------------------------------------

     // Mojo components

     // ----------------------------------------------------------------------

     /**

      * FO Document Renderer.

      */

     @Component( hint = "fo" )

     private PdfRenderer foRenderer;

     /**

      * Internationalization.

      */

     @Component

     private I18N i18n;

     /**

      * IText Document Renderer.

      */

     @Component( hint = "itext" )

     private PdfRenderer itextRenderer;

     /**

      * A comma separated list of locales supported by Maven.

      * The first valid token will be the default Locale for this instance of the Java Virtual Machine.

      */

     @Parameter( property = "locales" )

     private String locales;

     /**

      * Site renderer.

      */

     @Component

     private Renderer siteRenderer;

     /**

      * SiteTool.

      */

     @Component

     private SiteTool siteTool;

     /**

      * The Plugin manager instance used to resolve Plugin descriptors.

      *

      * @since 1.1

      */

     @Component( role = PluginManager.class )

     private PluginManager pluginManager;

     /**

      * Doxia.

      *

      * @since 1.1

      */

     @Component

     private Doxia doxia;

     /**

      * Project builder.

      *

      * @since 1.1

      */

     @Component

     private MavenProjectBuilder mavenProjectBuilder;

     // ----------------------------------------------------------------------

     // Mojo Parameters

     // ----------------------------------------------------------------------

     /**

      * The Maven Project Object.

      */

     @Parameter( defaultValue = "${project}", readonly = true, required = true )

     private MavenProject project;

     /**

      * The Maven Settings.

      *

      * @since 1.1

      */

     @Parameter( defaultValue = "${settings}", readonly = true, required = true )

     private Settings settings;

     /**

      * The current build session instance.

      *

      * @since 1.1

      */

     @Parameter( defaultValue = "${session}", readonly = true, required = true )

     private MavenSession session;

     /**

      * Directory containing source for apt, fml and xdoc docs.

      */

     @Parameter( defaultValue = "${basedir}/src/site", required = true )

     private File siteDirectory;

     /**

      * Directory containing generated sources for apt, fml and xdoc docs.

      *

      * @since 1.1

      */

     @Parameter( defaultValue = "${project.build.directory}/generated-site", required = true )

     private File generatedSiteDirectory;

     /**

      * Output directory where PDF files should be created.

      */

     @Parameter( defaultValue = "${project.build.directory}/pdf", required = true )

     private File outputDirectory;

     /**

      * Working directory for working files like temp files/resources.

      */

     @Parameter( defaultValue = "${project.build.directory}/pdf", required = true )

     private File workingDirectory;

     /**

      * File that contains the DocumentModel of the PDF to generate.

      */

     @Parameter( defaultValue = "src/site/pdf.xml" )

     private File docDescriptor;

     /**

      * Identifies the framework to use for pdf generation: either "fo" (default) or "itext".

      */

     @Parameter( property = "implementation", defaultValue = "fo", required = true )

     private String implementation;

     /**

      * The local repository.

      */

     @Parameter( defaultValue = "${localRepository}", required = true, readonly = true )

     private ArtifactRepository localRepository;

     /**

      * The remote repositories where artifacts are located.

      *

      * @since 1.1

      */

     @Parameter( defaultValue = "${project.remoteArtifactRepositories}"  )

     private List<ArtifactRepository> remoteRepositories;

     /**

      * If <code>true</false>, aggregate all source documents in one pdf, otherwise generate one pdf for each

      * source document.

      */

     @Parameter( property = "aggregate", defaultValue = "true" )

     private boolean aggregate;

     /**

      * The current version of this plugin.

      */

     @Parameter( defaultValue = "${plugin.version}", readonly = true )

     private String pluginVersion;

     /**

      * If <code>true</false>, generate all Maven reports defined in <code>${project.reporting}</code> and append

      * them as a new entry in the TOC (Table Of Contents).

      * <b>Note</b>: Including the report generation could fail the PDF generation or increase the build time.

      *

      * @since 1.1

      */

     @Parameter( property = "includeReports", defaultValue = "true" )

     private boolean includeReports;

     /**

      * Generate a TOC (Table Of Content) for all items defined in the <toc/> element from the document descriptor.

      * <br/>

      * Possible values are: 'none', 'start' and 'end'.

      *

      * @since 1.1

      */

     @Parameter( property = "generateTOC", defaultValue = "start" )

     private String generateTOC;

     /**

      * Whether to validate xml input documents.

      * If set to true, <strong>all</strong> input documents in xml format

      * (in particular xdoc and fml) will be validated and any error will

      * lead to a build failure.

      *

      * @since 1.2

      */

     @Parameter( property = "validate", defaultValue = "false" )

     private boolean validate;

     /**

      * Reports (Maven 2).

      * @since 1.3

      */

     @Parameter( defaultValue = "${reports}", required = true, readonly = true )

     private MavenReport[] reports;

     /**

      * <p>Configuration section <b>used internally</b> by Maven 3.</p>

      * <p>More details available here:

      * <a href="http://maven.apache.org/plugins/maven-site-plugin/maven-3.html#Configuration_formats" target="_blank">

      * http://maven.apache.org/plugins/maven-site-plugin/maven-3.html#Configuration_formats</a>

      * </p>

      * <p><b>Note:</b> using this field is not mandatory with Maven 3 as Maven core injects usual

      * <code>&lt;reporting&gt;</code> section into this field.</p>

      *

      * @since 1.3

      */

     @Parameter( readonly = true )

     private org.apache.maven.reporting.exec.ReportPlugin[] reportPlugins;

     // ----------------------------------------------------------------------

     // Instance fields

     // ----------------------------------------------------------------------

     /**

      * The current document Renderer.

      * @see #implementation

      */

     private DocumentRenderer docRenderer;

     /**

      * The default locale.

      */

     private Locale defaultLocale;

     /**

      * The available locales list.

      */

     private List<Locale> localesList;

     /**

      * The default decoration model.

      */

     private DecorationModel defaultDecorationModel;

     /**

      * The temp Site dir to have all site and generated-site files.

      *

      * @since 1.1

      */

     private File siteDirectoryTmp;

     /**

      * The temp Generated Site dir to have generated reports by this plugin.

      *

      * @since 1.1

      */

     private File generatedSiteDirectoryTmp;

     /**

      * A map of generated MavenReport list using locale as key.

      *

      * @since 1.1

      */

     private Map<Locale, List<MavenReport>> generatedMavenReports;

     /**

      * @since 1.3

      */

     private PlexusContainer container;

     // ----------------------------------------------------------------------

     // Public methods

     // ----------------------------------------------------------------------

     /** {@inheritDoc} */

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         init();

         try

         {

             generatePdf();

         }

         catch ( IOException e )

         {

             debugLogGeneratedModel( getDocumentModel( Locale.ENGLISH ) );

             throw new MojoExecutionException( "Error during document generation: " + e.getMessage(), e );

         }

         try

         {

             copyGeneratedPdf();

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( "Error copying generated PDF: " + e.getMessage(), e );

         }

     }

     /** {@inheritDoc} */

     public void contextualize( Context context )

         throws ContextException

     {

         container = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );

     }

     // ----------------------------------------------------------------------

     // Private methods

     // ----------------------------------------------------------------------

     /**

      * Init and validate parameters

      */

     private void init()

     {

         if ( "fo".equalsIgnoreCase( implementation ) )

         {

             this.docRenderer = foRenderer;

         }

         else if ( "itext".equalsIgnoreCase( implementation ) )

         {

             this.docRenderer = itextRenderer;

         }

         else

         {

             getLog().warn( "Invalid 'implementation' parameter: '" + implementation

                     + "', using 'fo' as default." );

             this.docRenderer = foRenderer;

         }

         if ( !( "none".equalsIgnoreCase( generateTOC )

                 || "start".equalsIgnoreCase( generateTOC ) || "end".equalsIgnoreCase( generateTOC ) ) )

         {

             getLog().warn( "Invalid 'generateTOC' parameter: '" + generateTOC

                     + "', using 'start' as default." );

             this.generateTOC = "start";

         }

     }

     /**

      * Copy the generated PDF to outputDirectory.

      *

      * @throws MojoExecutionException if any

      * @throws IOException if any

      * @since 1.1

      */

     private void copyGeneratedPdf()

         throws MojoExecutionException, IOException

     {

         if ( outputDirectory.getCanonicalPath().equals( workingDirectory.getCanonicalPath() ) )

         {

             return;

         }

         String outputName = getDocumentModel( getDefaultLocale() ).getOutputName().trim();

         if ( !outputName.endsWith( ".pdf" ) )

         {

             outputName = outputName.concat( ".pdf" );

         }

         for ( final Locale locale : getAvailableLocales() )

         {

             File generatedPdfSource = new File( getLocaleDirectory( workingDirectory, locale ), outputName );

             if ( !generatedPdfSource.exists() )

             {

                 getLog().warn( "Unable to find the generated pdf: " + generatedPdfSource.getAbsolutePath() );

                 continue;

             }

             File generatedPdfDest = new File( getLocaleDirectory( outputDirectory, locale ), outputName );

             FileUtils.copyFile( generatedPdfSource, generatedPdfDest );

             generatedPdfSource.delete();

         }

     }

     /**

      * Generate the PDF.

      *

      * @throws MojoExecutionException if any

      * @throws IOException if any

      * @since 1.1

      */

     private void generatePdf()

         throws MojoExecutionException, IOException

     {

         Locale.setDefault( getDefaultLocale() );

         for ( final Locale locale : getAvailableLocales() )

         {

             final File workingDir = getLocaleDirectory( workingDirectory, locale );

             File siteDirectoryFile = getLocaleDirectory( getSiteDirectoryTmp(), locale );

             copyResources( locale );

             generateMavenReports( locale );

             DocumentRendererContext context = new DocumentRendererContext();

             context.put( "project", project );

             context.put( "settings", settings );

             context.put( "PathTool", new PathTool() );

             context.put( "FileUtils", new FileUtils() );

             context.put( "StringUtils", new StringUtils() );

             context.put( "i18n", i18n );

             context.put( "generateTOC", generateTOC );

             context.put( "validate", validate );

             // Put any of the properties in directly into the Velocity context

             for ( Map.Entry<Object, Object> entry : project.getProperties().entrySet() )

             {

                 context.put( (String) entry.getKey(), entry.getValue() );

             }

             final DocumentModel model = aggregate ? getDocumentModel( locale ) : null;

             try

             {

                 // TODO use interface see DOXIASITETOOLS-30

                 ( (AbstractDocumentRenderer) docRenderer ).render( siteDirectoryFile, workingDir, model, context );

             }

             catch ( DocumentRendererException e )

             {

                 throw new MojoExecutionException( "Error during document generation: " + e.getMessage(), e );

             }

         }

     }

     /**

      * @return the default tmpSiteDirectory.

      * @throws IOException if any

      * @since 1.1

      */

     private File getSiteDirectoryTmp()

         throws IOException

     {

         if ( this.siteDirectoryTmp == null )

         {

             final File tmpSiteDir = new File( workingDirectory, "site.tmp" );

             prepareTempSiteDirectory( tmpSiteDir );

             this.siteDirectoryTmp = tmpSiteDir;

         }

         return this.siteDirectoryTmp;

     }

     /**

      * @return the default tmpGeneratedSiteDirectory when report will be created.

      * @since 1.1

      */

     private File getGeneratedSiteDirectoryTmp()

     {

         if ( this.generatedSiteDirectoryTmp == null )

         {

             this.generatedSiteDirectoryTmp = new File( workingDirectory, "generated-site.tmp" );

         }

         return this.generatedSiteDirectoryTmp;

     }

     /**

      * Copy all site and generated-site files in the tmpSiteDirectory.

      * <br/>

      * <b>Note</b>: ignore copying of <code>generated-site</code> files if they already exist in the

      * <code>site</code> dir.

      *

      * @param tmpSiteDir not null

      * @throws IOException if any

      * @since 1.1

      */

     private void prepareTempSiteDirectory( final File tmpSiteDir )

         throws IOException

     {

         // safety

         tmpSiteDir.mkdirs();

         // copy site

         if ( siteDirectory.exists() )

         {

             FileUtils.copyDirectoryStructure( siteDirectory, tmpSiteDir );

         }

         // Remove SCM files

         List<String> files =

             FileUtils.getFileAndDirectoryNames( tmpSiteDir, FileUtils.getDefaultExcludesAsString(), null, true,

                                                 true, true, true );

         for ( final String fileName : files )

         {

             final File file = new File( fileName );

             if ( file.isDirectory() )

             {

                 FileUtils.deleteDirectory( file );

             }

             else

             {

                 file.delete();

             }

         }

         copySiteDir( generatedSiteDirectory, tmpSiteDir );

     }

     /**

      * Copy the from site dir to the to dir.

      *

      * @param from not null

      * @param to not null

      * @throws IOException if any

      * @since 1.1

      */

     private void copySiteDir( final File from, final File to )

         throws IOException

     {

         if ( from == null || !from.exists() )

         {

             return;

         }

         // copy generated-site

         for ( final Locale locale : getAvailableLocales() )

         {

             String excludes = getDefaultExcludesWithLocales( getAvailableLocales(), getDefaultLocale() );

             List<String> siteFiles = FileUtils.getFileNames( siteDirectory, "**/*", excludes, false );

             File siteDirectoryLocale = new File( siteDirectory, locale.getLanguage() );

             if ( !locale.getLanguage().equals( getDefaultLocale().getLanguage() ) && siteDirectoryLocale.exists() )

             {

                 siteFiles = FileUtils.getFileNames( siteDirectoryLocale, "**/*", excludes, false );

             }

             List<String> generatedSiteFiles = FileUtils.getFileNames( from, "**/*", excludes, false );

             File fromLocale = new File( from, locale.getLanguage() );

             if ( !locale.getLanguage().equals( getDefaultLocale().getLanguage() ) && fromLocale.exists() )

             {

                 generatedSiteFiles = FileUtils.getFileNames( fromLocale, "**/*", excludes, false );

             }

             for ( final String generatedSiteFile : generatedSiteFiles )

             {

                 if ( siteFiles.contains( generatedSiteFile ) )

                 {

                     getLog().warn( "Generated-site already contains a file in site: " + generatedSiteFile

                                        + ". Ignoring copying it!" );

                     continue;

                 }

                 if ( !locale.getLanguage().equals( getDefaultLocale().getLanguage() ) )

                 {

                     if ( fromLocale.exists() )

                     {

                         File in = new File( fromLocale, generatedSiteFile );

                         File out = new File( new File( to, locale.getLanguage() ), generatedSiteFile );

                         out.getParentFile().mkdirs();

                         FileUtils.copyFile( in, out );

                     }

                 }

                 else

                 {

                     File in = new File( from, generatedSiteFile );

                     File out = new File( to, generatedSiteFile );

                     out.getParentFile().mkdirs();

                     FileUtils.copyFile( in, out );

                 }

             }

         }

     }

     /**

      * Constructs a DocumentModel for the current project. The model is either read from

      * a descriptor file, if it exists, or constructed from information in the pom and site.xml.

      *

      * @param locale not null

      * @return DocumentModel.

      * @throws MojoExecutionException if any

      * @see #appendGeneratedReports(DocumentModel, Locale)

      */

     private DocumentModel getDocumentModel( Locale locale )

         throws MojoExecutionException

     {

         if ( docDescriptor.exists() )

         {

             DocumentModel doc = getDocumentModelFromDescriptor( locale );

             // TODO: descriptor model should get merged into default model, see MODELLO-63

             appendGeneratedReports( doc, locale );

             return doc;

         }

         DocumentModel model = new DocumentModelBuilder( project, getDefaultDecorationModel() ).getDocumentModel();

         model.getMeta().setGenerator( getDefaultGenerator() );

         model.getMeta().setLanguage( locale.getLanguage() );

         model.getCover().setCoverType( i18n.getString( "pdf-plugin", getDefaultLocale(), "toc.type" ) );

         model.getToc().setName( i18n.getString( "pdf-plugin", getDefaultLocale(), "toc.title" ) );

         appendGeneratedReports( model, locale );

         debugLogGeneratedModel( model );

         return model;

     }

     /**

      * Read a DocumentModel from a file.

      *

      * @param locale used to set the language.

      * @return the DocumentModel read from the configured document descriptor.

      * @throws org.apache.maven.plugin.MojoExecutionException if the model could not be read.

      */

     private DocumentModel getDocumentModelFromDescriptor( Locale locale )

         throws MojoExecutionException

     {

         DocumentModel model;

         try

         {

             model =

                 new DocumentDescriptorReader( project, getLog() ).readAndFilterDocumentDescriptor( docDescriptor );

         }

         catch ( XmlPullParserException ex )

         {

             throw new MojoExecutionException( "Error reading DocumentDescriptor!", ex );

         }

         catch ( IOException io )

         {

             throw new MojoExecutionException( "Error opening DocumentDescriptor!", io );

         }

         if ( model.getMeta() == null )

         {

             model.setMeta( new DocumentMeta() );

         }

         if ( StringUtils.isEmpty( model.getMeta().getLanguage() ) )

         {

             model.getMeta().setLanguage( locale.getLanguage() );

         }

         if ( StringUtils.isEmpty( model.getMeta().getGenerator() ) )

         {

             model.getMeta().setGenerator( getDefaultGenerator() );

         }

         return model;

     }

     /**

      * Return the directory for a given Locale and the current default Locale.

      *

      * @param basedir the base directory

      * @param locale a Locale.

      * @return File.

      */

     private File getLocaleDirectory( File basedir, Locale locale )

     {

         if ( locale.getLanguage().equals( getDefaultLocale().getLanguage() ) )

         {

             return basedir;

         }

         return new File( basedir, locale.getLanguage() );

     }

     /**

      * @return the default locale from <code>siteTool</code>.

      * @see #getAvailableLocales()

      */

     private Locale getDefaultLocale()

     {

         if ( this.defaultLocale == null )

         {

             this.defaultLocale = getAvailableLocales().get( 0 );

         }

         return this.defaultLocale;

     }

     /**

      * @return the available locales from <code>siteTool</code>.

      * @see SiteTool#getAvailableLocales(String)

      */

     private List<Locale> getAvailableLocales()

     {

         if ( this.localesList == null )

         {

             this.localesList = siteTool.getAvailableLocales( locales );

         }

         return this.localesList;

     }

     /**

      * @return the DecorationModel instance from <code>site.xml</code>

      * @throws MojoExecutionException if any

      */

     private DecorationModel getDefaultDecorationModel()

         throws MojoExecutionException

     {

         if ( this.defaultDecorationModel == null )

         {

             final Locale locale = getDefaultLocale();

             final File basedir = project.getBasedir();

             final String relativePath =

                 siteTool.getRelativePath( siteDirectory.getAbsolutePath(), basedir.getAbsolutePath() );

             final File descriptorFile = siteTool.getSiteDescriptorFromBasedir( relativePath, basedir, locale );

             DecorationModel decoration = null;

             if ( descriptorFile.exists() )

             {

                 XmlStreamReader reader = null;

                 try

                 {

                     reader = new XmlStreamReader( descriptorFile );

                     String enc = reader.getEncoding();

                     String siteDescriptorContent = IOUtil.toString( reader );

                     siteDescriptorContent =

                         siteTool.getInterpolatedSiteDescriptorContent( new HashMap<String, String>( 2 ), project,

                                                                        siteDescriptorContent, enc, enc );

                     decoration = new DecorationXpp3Reader().read( new StringReader( siteDescriptorContent ) );

                 }

                 catch ( XmlPullParserException e )

                 {

                     throw new MojoExecutionException( "Error parsing site descriptor", e );

                 }

                 catch ( IOException e )

                 {

                     throw new MojoExecutionException( "Error reading site descriptor", e );

                 }

                 catch ( SiteToolException e )

                 {

                     throw new MojoExecutionException( "Error when interpoling site descriptor", e );

                 }

                 finally

                 {

                     IOUtil.close( reader );

                 }

             }

             this.defaultDecorationModel = decoration;

         }

         return this.defaultDecorationModel;

     }

     /**

      * Parse the decoration model to find the skin artifact and copy its resources to the output dir.

      *

      * @param locale not null

      * @throws MojoExecutionException if any

      * @see #getDefaultDecorationModel()

      */

     private void copyResources( Locale locale )

         throws MojoExecutionException

     {

         final DecorationModel decorationModel = getDefaultDecorationModel();

         if ( decorationModel == null )

         {

             return;

         }

         File skinFile;

         try

         {

             skinFile =

                 siteTool.getSkinArtifactFromRepository( localRepository, project.getRemoteArtifactRepositories(),

                                                         decorationModel ).getFile();

         }

         catch ( SiteToolException e )

         {

             throw new MojoExecutionException( "SiteToolException: " + e.getMessage(), e );

         }

         if ( skinFile == null )

         {

             return;

         }

         if ( getLog().isDebugEnabled() )

         {

             getLog().debug( "Copy resources from skin artifact: '" + skinFile + "'..." );

         }

         try

         {

             final SiteRenderingContext context =

                 siteRenderer.createContextForSkin( skinFile, new HashMap( 2 ), decorationModel, project.getName(),

                                                    locale );

             context.addSiteDirectory( new File( siteDirectory, locale.getLanguage() ) );

             for ( final File siteDirectoryFile : context.getSiteDirectories() )

             {

                 siteRenderer.copyResources( context, new File( siteDirectoryFile, "resources" ), workingDirectory );

             }

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( "IOException: " + e.getMessage(), e );

         }

     }

     /**

      * Construct a default producer.

      *

      * @return A String in the form <code>Maven PDF Plugin v. 1.1.1, 'fo' implementation</code>.

      */

     private String getDefaultGenerator()

     {

         return "Maven PDF Plugin v. " + pluginVersion + ", '" + implementation + "' implementation.";

     }

     /**

      * Write the auto-generated model to disc.

      *

      * @param docModel the model to write.

      */

     private void debugLogGeneratedModel( final DocumentModel docModel )

     {

         if ( getLog().isDebugEnabled() && project != null )

         {

             final File outputDir = new File( project.getBuild().getDirectory(), "pdf" );

             if ( !outputDir.exists() )

             {

                 outputDir.mkdirs();

             }

             final File doc = FileUtils.createTempFile( "pdf", ".xml", outputDir );

             final DocumentXpp3Writer xpp3 = new DocumentXpp3Writer();

             Writer w = null;

             try

             {

                 w = WriterFactory.newXmlWriter( doc );

                 xpp3.write( w, docModel );

                 getLog().debug( "Generated a default document model: " + doc.getAbsolutePath() );

             }

             catch ( IOException e )

             {

                 getLog().error( "Failed to write document model: " + e.getMessage() );

                 getLog().debug( e );

             }

             finally

             {

                 IOUtil.close( w );

             }

         }

     }

     /**

      * Generate all Maven reports defined in <code>${project.reporting}</code> part

      * only if <code>generateReports</code> is enabled.

      *

      * @param locale not null

      * @throws MojoExecutionException if any

      * @throws IOException if any

      * @since 1.1

      */

     private void generateMavenReports( Locale locale )

         throws MojoExecutionException, IOException

     {

         if ( !includeReports )

         {

             getLog().info( "Skipped report generation." );

             return;

         }

         if ( project.getReporting() == null )

         {

             getLog().info( "No report was specified." );

             return;

         }

         for ( final ReportPlugin reportPlugin : project.getReporting().getPlugins() )

         {

             final PluginDescriptor pluginDescriptor = getPluginDescriptor( reportPlugin );

             if ( pluginDescriptor != null )

             {

                 List<String> goals = new ArrayList<String>( 8 );

                 for ( final ReportSet reportSet : reportPlugin.getReportSets() )

                 {

                     for ( String goal : reportSet.getReports() )

                     {

                         goals.add( goal );

                     }

                 }

                 List mojoDescriptors = pluginDescriptor.getMojos();

                 for ( Object mojoDescriptor1 : mojoDescriptors )

                 {

                     final MojoDescriptor mojoDescriptor = (MojoDescriptor) mojoDescriptor1;

                     if ( goals.isEmpty() || ( !goals.isEmpty() && goals.contains( mojoDescriptor.getGoal() ) ) )

                     {

                         MavenReport report = getMavenReport( mojoDescriptor );

                         generateMavenReport( report, mojoDescriptor.getPluginDescriptor().getPluginArtifact(),

                                              locale );

                     }

                 }

             }

         }

         // generate project-info report

         if ( !getGeneratedMavenReports( locale ).isEmpty() )

         {

             File outDir = new File( getGeneratedSiteDirectoryTmp(), "xdoc" );

             if ( !locale.getLanguage().equals( defaultLocale.getLanguage() ) )

             {

                 outDir = new File( new File( getGeneratedSiteDirectoryTmp(), locale.getLanguage() ), "xdoc" );

             }

             outDir.mkdirs();

             File piReport = new File( outDir, "project-info.xml" );

             StringWriter sw = new StringWriter();

             PdfSink sink = new PdfSink( sw );

             ProjectInfoRenderer r = new ProjectInfoRenderer( sink, getGeneratedMavenReports( locale ), i18n, locale );

             r.render();

             writeGeneratedReport( sw.toString(), piReport );

         }

         // copy generated site

         copySiteDir( getGeneratedSiteDirectoryTmp(), getSiteDirectoryTmp() );

         copySiteDir( generatedSiteDirectory, getSiteDirectoryTmp() );

     }

     /**

      * TODO olamy : remove when maven 3 will be the de facto standard :-)

      * @param reportPlugin not null

      * @return the PluginDescriptor instance for the given reportPlugin.

      * @throws MojoExecutionException if any

      * @since 1.1

      */

     private PluginDescriptor getPluginDescriptor( ReportPlugin reportPlugin )

         throws MojoExecutionException

     {

         try

         {

             return pluginManager.verifyReportPlugin( reportPlugin, project, session );

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException( "ArtifactResolutionException: " + e.getMessage(), e );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException( "ArtifactNotFoundException: " + e.getMessage(), e );

         }

         catch ( PluginNotFoundException e )

         {

             throw new MojoExecutionException( "PluginNotFoundException: " + e.getMessage(), e );

         }

         catch ( PluginVersionResolutionException e )

         {

             throw new MojoExecutionException( "PluginVersionResolutionException: " + e.getMessage(), e );

         }

         catch ( InvalidVersionSpecificationException e )

         {

             throw new MojoExecutionException( "InvalidVersionSpecificationException: " + e.getMessage(), e );

         }

         catch ( InvalidPluginException e )

         {

             throw new MojoExecutionException( "InvalidPluginException: " + e.getMessage(), e );

         }

         catch ( PluginManagerException e )

         {

             throw new MojoExecutionException( "PluginManagerException: " + e.getMessage(), e );

         }

         catch ( PluginVersionNotFoundException e )

         {

             throw new MojoExecutionException( "PluginVersionNotFoundException: " + e.getMessage(), e );

         }

         catch ( NoSuchMethodError e )

         {

             getLog().info( "Ignoring api call removed in maven 3, no reports are generated!" );

             getLog().debug( e );

             return null;

         }

     }

     /**

      * @param mojoDescriptor not null

      * @return the MavenReport instance for the given mojoDescriptor.

      * @throws MojoExecutionException if any

      * @since 1.1

      */

     private MavenReport getMavenReport( MojoDescriptor mojoDescriptor )

         throws MojoExecutionException

     {

         ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();

         try

         {

             Thread.currentThread()

                   .setContextClassLoader( mojoDescriptor.getPluginDescriptor().getClassRealm().getClassLoader() );

             MojoExecution mojoExecution = new MojoExecution( mojoDescriptor );

             return pluginManager.getReport( project, mojoExecution, session );

         }

         catch ( ArtifactNotFoundException e )

         {

             throw new MojoExecutionException( "ArtifactNotFoundException: " + e.getMessage(), e );

         }

         catch ( ArtifactResolutionException e )

         {

             throw new MojoExecutionException( "ArtifactResolutionException: " + e.getMessage(), e );

         }

         catch ( PluginConfigurationException e )

         {

             throw new MojoExecutionException( "PluginConfigurationException: " + e.getMessage(), e );

         }

         catch ( PluginManagerException e )

         {

             throw new MojoExecutionException( "PluginManagerException: " + e.getMessage(), e );

         }

         finally

         {

             Thread.currentThread().setContextClassLoader( oldClassLoader );

         }

     }

     /**

      * Generate the given Maven report only if it is not an external report and the report could be generated.

      *

      * @param mojoDescriptor not null, to catch linkage error

      * @param report could be null

      * @param locale not null

      * @throws IOException if any

      * @throws MojoExecutionException if any

      * @see #isValidGeneratedReport(MojoDescriptor, File, String)

      * @since 1.1

      */

     private void generateMavenReport( MavenReport report, Artifact pluginArtifact, Locale locale )

         throws IOException, MojoExecutionException

     {

         if ( report == null )

         {

             return;

         }

         String localReportName = report.getName( locale );

         if ( !report.canGenerateReport() )

         {

             getLog().info( "Skipped \"" + localReportName + "\" report." );

             getLog().debug( "canGenerateReport() was false." );

             return;

         }

         if ( report.isExternalReport() )

         {

             getLog().info( "Skipped external \"" + localReportName + "\" report." );

             getLog().debug( "isExternalReport() was false." );

             return;

         }

         for ( final MavenReport generatedReport : getGeneratedMavenReports( locale ) )

         {

             if ( report.getName( locale ).equals( generatedReport.getName( locale ) ) )

             {

                 if ( getLog().isDebugEnabled() )

                 {

                     getLog().debug( report.getName( locale ) + " was already generated." );

                 }

                 return;

             }

         }

         File outDir = new File( getGeneratedSiteDirectoryTmp(), "xdoc" );

         if ( !locale.getLanguage().equals( defaultLocale.getLanguage() ) )

         {

             outDir = new File( new File( getGeneratedSiteDirectoryTmp(), locale.getLanguage() ), "xdoc" );

         }

         outDir.mkdirs();

         File generatedReport = new File( outDir, report.getOutputName() + ".xml" );

         String excludes = getDefaultExcludesWithLocales( getAvailableLocales(), getDefaultLocale() );

         List<String> files =

             FileUtils.getFileNames( siteDirectory, "*/" + report.getOutputName() + ".*", excludes, false );

         if ( !locale.getLanguage().equals( defaultLocale.getLanguage() ) )

         {

             files =

                 FileUtils.getFileNames( new File( siteDirectory, locale.getLanguage() ), "*/"

                     + report.getOutputName() + ".*", excludes, false );

         }

         if ( files.size() != 0 )

         {

             String displayLanguage = locale.getDisplayLanguage( Locale.ENGLISH );

             if ( getLog().isInfoEnabled() )

             {

                 getLog().info(

                                "Skipped \"" + report.getName( locale ) + "\" report, file \""

                                    + report.getOutputName() + "\" already exists for the " + displayLanguage

                                    + " version." );

             }

             return;

         }

         if ( getLog().isInfoEnabled() )

         {

             getLog().info( "Generating \"" + localReportName + "\" report." );

         }

         StringWriter sw = new StringWriter();

         PdfSink sink = null;

         try

         {

             sink = new PdfSink( sw );

             org.codehaus.doxia.sink.Sink proxy = (org.codehaus.doxia.sink.Sink) Proxy.newProxyInstance(

                 org.codehaus.doxia.sink.Sink.class.getClassLoader(),

                 new Class[] { org.codehaus.doxia.sink.Sink.class }, new SinkDelegate( sink ) );

             report.generate( proxy, locale );

         }

         catch ( MavenReportException e )

         {

             throw new MojoExecutionException( "MavenReportException: " + e.getMessage(), e );

         }

         finally

         {

             if ( sink != null )

             {

                 sink.close();

             }

         }

         writeGeneratedReport( sw.toString(), generatedReport );

         if ( isValidGeneratedReport( pluginArtifact, generatedReport, localReportName ) )

         {

             getGeneratedMavenReports( locale ).add( report );

         }

     }

     /**

      * @param locale not null

      * @return the generated reports

      * @see #generateMavenReport(MojoDescriptor, MavenReport, Locale)

      * @see #isValidGeneratedReport(MojoDescriptor, File, String)

      * @since 1.1

      */

     private List<MavenReport> getGeneratedMavenReports( Locale locale )

     {

         if ( this.generatedMavenReports == null )

         {

             this.generatedMavenReports = new HashMap<Locale, List<MavenReport>>( 2 );

         }

         if ( this.generatedMavenReports.get( locale ) == null )

         {

             this.generatedMavenReports.put( locale, new ArrayList<MavenReport>( 2 ) );

         }

         return this.generatedMavenReports.get( locale );

     }

     /**

      * Append generated reports to the toc only if <code>generateReports</code> is enabled, for instance:

      * <pre>

      * <item name="Project Reports" ref="/project-info">

      *   <item name="Project License" ref="/license" />

      *   <item name="Project Team" ref="/team-list" />

      *   <item name="Continuous Integration" ref="/integration" />

      *   ...

      * </item>