/*
    * Copyright 2010-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.testdoc.maven;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Locale;
  import java.util.Set;
  
  import javax.xml.stream.XMLOutputFactory;
  import javax.xml.stream.XMLStreamException;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.maven.doxia.sink.Sink;
  import org.apache.maven.reporting.MavenReportException;
  
  import de.smartics.maven.util.PathUtils;
  import de.smartics.testdoc.maven.export.sink.SinkExporter;
  import de.smartics.testdoc.maven.export.sink.SinkOutputManager;
  import de.smartics.testdoc.maven.export.xml.XmlExporter;
  import de.smartics.testdoc.maven.export.xml.XmlOutputManager;
  import de.smartics.testdoc.core.doc.OutputManager;
  import de.smartics.testdoc.core.doc.UnitTestDoc;
  import de.smartics.testdoc.core.doc.UnitTestDocIndex;
  import de.smartics.testdoc.core.export.UnitTestDocIndexExporter;
  import de.smartics.testdoc.report.export.doc.IndexProvider;
  import de.smartics.testdoc.report.export.doc.InformationFilter;
  import de.smartics.testdoc.report.export.doc.ReportConfig;
  import de.smartics.testdoc.report.export.doc.SelectionFilter;
  import de.smartics.testdoc.report.export.doc.TestDocHelper;
  import de.smartics.testdoc.report.index.ExportIndex;
  
  /**
   * Generates XDoc reports.
   *
   * @goal test-stories-report
   * @execute phase="test" lifecycle="testdoc"
   * @requiresProject
   * @requiresDependencyResolution test
   * @description Generates XDoc reports.
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public class TestDocReportMojo extends AbstractSourceReportMojo
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The output directory to write intermediate serialized files to.
     *
     * @parameter expression="${project.build.directory}/testdoc/ser"
     * @since 1.0
     */
    private String serOutputDirectory;
  
    /**
     * Helper methods to access test documentation information.
     */
    private TestDocHelper testDocHelper;
  
    /**
     * The name of categories of test scenarios that should be excluded. If a
     * scenario is tagged by at least one of the mentioned filters, it will not be
     * displayed in the report.
     * <p>
     * The category is specified as a JUnit <code>Category</code>. The name to
     * specify here is the full qualified type specified in the category
     * annotation.
     * </p>
     * <p>
     * Per default, if no filter category is specified, no category is excluded.
     * </p>
     *
     * @parameter
     * @since 1.0
     */
   private List<String> excludeCategories;
 
   /**
    * The name of categories of test scenarios that should be included. If a
    * scenario is tagged by at least one of the mentioned filters, it will not be
    * displayed in the report.
    * <p>
    * The category is specified as a JUnit <code>Category</code>. The name to
    * specify here is the full qualified type specified in the category
    * annotation.
    * </p>
    * <p>
    * Per default, if no filter category is specified, all categories are
    * included.
    * </p>
    *
    * @parameter
    * @since 1.0
    */
   private List<String> includeCategories;
 
   /**
    * The class names of implementations of {@link ExportIndex}. The
    * implementations are required to provide a no-arg constructor.
    *
    * @parameter
    * @since 1.0
    */
   private List<String> indices;
 
   /**
    * The name of the comparator to compare {@link UnitTestDoc} instances. The
    * default implementation compares the simple name of the UUT type. An
    * alternative implementation, sorting by the qualified name of the UUT, is
    * <code>de.smartics.testdoc.core.doc.UnitTestDocTypeSimpleNameComparator</code>.
    * The implementation is required to provide a no-arg constructor.
    *
    * @parameter default-value=
    *            "de.smartics.testdoc.core.doc.UnitTestDocTypeSimpleNameComparator"
    * @since 1.0
    */
   private String unitTestDocComparator;
 
   /**
    * The names of report formats to export to. Currently only <code>site</code>
    * and <code>xml</code> are supported. If no format is configured,
    * <code>site</code> is assumed.
    *
    * @parameter
    * @since 1.0
    */
   private Set<String> formats;
 
   /**
    * The directory to write a pure XML report to. This report contains the same
    * information as the site report. To generate the report, the
    * <code>formats</code> have to provide the format <code>xml</code>.
    *
    * @parameter
    *            default-value="${project.build.directory}/testdoc-reports"
    */
   private File xmlReportDir;
 
   /**
    * The flag that tells whether (<code>true</code>) or not (<code>false</code>)
    * the index over all indices should be shown.
    *
    * @parameter default-value="true"
    * @since 1.0
    */
   private boolean showIndexOfIndices;
 
   /**
    * The flag that tells whether (<code>true</code>) or not (<code>false</code>)
    * the number column should be shown when enumerating the test cases.
    *
    * @parameter default-value="true"
    * @since 1.0
    */
   private boolean showNumbering;
 
   /**
    * The flag that tells whether (<code>true</code>) or not (<code>false</code>)
    * the test status column should be shown when enumerating the test cases.
    *
    * @parameter default-value="true"
    * @since 1.0
    */
   private boolean showTestStatus;
 
   /**
    * The flag that tells whether (<code>true</code>) or not (<code>false</code>)
    * the categories should be shown when enumerating the test cases.
    *
    * @parameter default-value="true"
    * @since 1.0
    */
   private boolean showCategories;
 
   /**
    * The flag that tells whether (<code>true</code>) or not (<code>false</code>)
    * the test case name should be shown.
    *
    * @parameter default-value="true"
    * @since 1.0
    */
   private boolean showTestCase;
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    */
   @Override
   protected void executeReport(final Locale locale) throws MavenReportException
   {
     if (canGenerateReport())
     {
       super.executeReport(locale);
       final IndexProvider indexChecker = new IndexProvider(serOutputDirectory);
       final ReportConfig reportConfig = createReportConfig();
       testDocHelper = indexChecker.createHelper(reportConfig);
       if (testDocHelper.isIndexProvided())
       {
         exportIndex(locale);
       }
       else
       {
         getLog().info(
             "No test doc information found, no report will be generated.");
       }
     }
     else
     {
       getLog().debug("Skipping testdoc report.");
     }
   }
 
   protected void exportIndex(final Locale locale) throws MavenReportException
   {
     try
     {
       final List<ExportIndex> exportIndices = createExportIndices();
       final UnitTestDocIndex index = testDocHelper.getIndex();
 
       if (formats == null || formats.contains("site"))
       {
         exportSinkReport(exportIndices, index);
       }
 
       if (formats != null && formats.contains("xml"))
       {
         exportXmlReport(exportIndices, index);
       }
     }
     catch (IOException e)
     {
       throw new MavenReportException("Cannot generate testdoc XML files.", e);
     }
   }
 
   protected void exportSinkReport(final List<ExportIndex> exportIndices,
       final UnitTestDocIndex index) throws IOException
   {
     final Sink sink = getSink();
     final SinkExporter exporter =
         new SinkExporter(messages, testDocHelper, sink);
     final OutputManager manager =
         new SinkOutputManager(outputName, messages, exporter, exportIndices);
     final UnitTestDocIndexExporter indexExporter =
         new UnitTestDocIndexExporter(manager);
     indexExporter.export(index);
   }
 
   protected void exportXmlReport(final List<ExportIndex> exportIndices,
       final UnitTestDocIndex index) throws IOException
   {
     OutputStream output = null;
     try
     {
       final XMLOutputFactory xof = XMLOutputFactory.newInstance();
       try
       {
         final File xmlReportFile = new File(xmlReportDir, outputName + ".xml");
         output = FileUtils.openOutputStream(xmlReportFile);
         final XmlExporter exporter =
             new XmlExporter(messages, testDocHelper, xof.createXMLStreamWriter(output, "UTF-8"));
         final OutputManager manager =
             new XmlOutputManager(outputName, messages, exporter, exportIndices);
         final UnitTestDocIndexExporter indexExporter =
             new UnitTestDocIndexExporter(manager);
         indexExporter.export(index);
       }
       catch (final XMLStreamException e)
       {
         throw new IOException("Cannot create XML writer.", e);
       }
 
     }
     finally
     {
       IOUtils.closeQuietly(output);
     }
   }
 
   @SuppressWarnings("unchecked")
   private List<ExportIndex> createExportIndices() throws MavenReportException
   {
     if (indices != null)
     {
       final List<ExportIndex> list = new ArrayList<ExportIndex>(indices.size());
       for (final String exportIndexClassName : indices)
       {
         try
         {
           final Class<? extends ExportIndex> type =
               (Class<? extends ExportIndex>) Class
                   .forName(exportIndexClassName);
           final ExportIndex index = type.newInstance();
           list.add(index);
         }
         catch (final ClassNotFoundException e)
         {
           throw new MavenReportException("Unknown export index type '"
                                          + exportIndexClassName + "'.", e);
         }
         catch (final InstantiationException e)
         {
           throw new MavenReportException(
               "Cannot instantiate export index type '" + exportIndexClassName
                   + "'.", e);
         }
         catch (final IllegalAccessException e)
         {
           throw new MavenReportException("Cannot access export index type '"
                                          + exportIndexClassName + "'.", e);
         }
       }
 
       return list;
     }
     return Collections.emptyList();
   }
 
   private ReportConfig createReportConfig() throws MavenReportException
   {
     final InformationFilter.Builder builder = new InformationFilter.Builder();
     builder.setShowIndexOfIndices(showIndexOfIndices);
     builder.setShowNumbering(showNumbering);
     builder.setShowCategories(showCategories);
     builder.setShowTestCase(showTestCase);
     builder.setShowTestStatus(showTestStatus);
     final InformationFilter filter = builder.build();
 
     final SelectionFilter selectionFilter =
         new SelectionFilter(includeCategories, excludeCategories);
     final Comparator<UnitTestDoc> comparator = createComparator();
     final ReportConfig config =
         new ReportConfig(selectionFilter, filter, junitManager, imageHelper,
             reports, comparator);
     return config;
   }
 
   @SuppressWarnings("unchecked")
   private Comparator<UnitTestDoc> createComparator()
     throws MavenReportException
   {
     try
     {
       final Class<Comparator<UnitTestDoc>> type =
           (Class<Comparator<UnitTestDoc>>) Class.forName(unitTestDocComparator);
       return type.newInstance();
     }
     catch (final ClassNotFoundException e)
     {
       throw new MavenReportException(
           "Unknown comparator type for unit test doc instances '"
               + unitTestDocComparator + "'.", e);
     }
     catch (final InstantiationException e)
     {
       throw new MavenReportException(
           "Cannot instantiate unit test doc comparator of type '"
               + unitTestDocComparator + "'.", e);
     }
     catch (final IllegalAccessException e)
     {
       throw new MavenReportException(
           "Cannot access unit test doc comparator of type '"
               + unitTestDocComparator + "'.", e);
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.apache.maven.reporting.AbstractMavenReport#canGenerateReport()
    */
   @Override
   @SuppressWarnings("unchecked")
   public boolean canGenerateReport()
   {
     final String packaging = project.getPackaging();
     return super.canGenerateReport()
            && !("pom".equals(packaging) || !PathUtils.exists(project
                .getTestCompileSourceRoots()));
   }
 
   // --- object basics --------------------------------------------------------
 
 }