/*
    * 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.
   */
  package org.apache.maven.plugins.pmd;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  
  /**
   * Base class for mojos that check if there were any PMD violations.
   *
   * @param <D> type of the check, e.g. {@link org.apache.maven.plugins.pmd.model.Violation}
   * or {@link org.apache.maven.plugins.pmd.model.Duplication}.
   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
   * @version $Id$
   */
  public abstract class AbstractPmdViolationCheckMojo<D> extends AbstractMojo {
      /**
       * The location of the XML report to check, as generated by the PMD report.
       */
      @Parameter(property = "project.build.directory", required = true)
      private File targetDirectory;
  
      /**
       * Whether to fail the build if the validation check fails.
       * The properties {@code failurePriority} and {@code maxAllowedViolations} control
       * under which conditions exactly the build should be failed.
       */
      @Parameter(property = "pmd.failOnViolation", defaultValue = "true", required = true)
      protected boolean failOnViolation;
  
      /**
       * Whether to build an aggregated report at the root, or build individual reports.
       *
       * @since 2.2
       * @deprecated since 3.15.0 Use the goal <code>pmd:aggregate-check</code> or
       * <code>pmd:aggregate-cpd-check</code> instead.
       */
      @Parameter(property = "aggregate", defaultValue = "false")
      @Deprecated
      protected boolean aggregate;
  
      /**
       * Print details of check failures to build output.
       */
      @Parameter(property = "pmd.verbose", defaultValue = "false")
      private boolean verbose;
  
      /**
       * Print details of errors that cause build failure
       *
       * @since 3.0
       */
      @Parameter(property = "pmd.printFailingErrors", defaultValue = "false")
      private boolean printFailingErrors;
  
      /**
       * File that lists classes and rules to be excluded from failures.
       * For PMD, this is a properties file. For CPD, this
       * is a text file that contains comma-separated lists of classes
       * that are allowed to duplicate.
       *
       * @since 3.0
       */
      @Parameter(property = "pmd.excludeFromFailureFile", defaultValue = "")
      private String excludeFromFailureFile;
  
      /**
       * The maximum number of failures allowed before execution fails.
       * Used in conjunction with {@code failOnViolation=true} and utilizes {@code failurePriority}.
       * This value has no meaning if {@code failOnViolation=false}.
       * If the number of failures is greater than this number, the build will be failed.
       * If the number of failures is less than or equal to this value,
       * then the build will not be failed.
       *
      * @since 3.10.0
      */
     @Parameter(property = "pmd.maxAllowedViolations", defaultValue = "0")
     private int maxAllowedViolations;
 
     /** Helper to exclude violations from the result. */
     private final ExcludeFromFile<D> excludeFromFile;
 
     /**
      * Initialize this abstact check mojo by giving the correct ExcludeFromFile helper.
      * @param excludeFromFile the needed helper, for the specific violation type
      */
     protected AbstractPmdViolationCheckMojo(ExcludeFromFile<D> excludeFromFile) {
         this.excludeFromFile = excludeFromFile;
     }
 
     /**
      * The project to analyze.
      */
     @Parameter(defaultValue = "${project}", readonly = true, required = true)
     protected MavenProject project;
 
     protected void executeCheck(
             final String filename, final String tagName, final String key, final int failurePriority)
             throws MojoFailureException, MojoExecutionException {
         if (aggregate && !project.isExecutionRoot()) {
             return;
         }
 
         if (!isAggregator() && "pom".equalsIgnoreCase(project.getPackaging())) {
             return;
         }
 
         excludeFromFile.loadExcludeFromFailuresData(excludeFromFailureFile);
         final File outputFile = new File(targetDirectory, filename);
 
         if (outputFile.exists()) {
             getLog().info("PMD version: " + AbstractPmdReport.getPmdVersion());
 
             try {
                 final ViolationDetails<D> violations = getViolations(outputFile, failurePriority);
 
                 final List<D> failures = violations.getFailureDetails();
                 final List<D> warnings = violations.getWarningDetails();
 
                 if (verbose) {
                     printErrors(failures, warnings);
                 }
 
                 final int failureCount = failures.size();
                 final int warningCount = warnings.size();
 
                 final String message = getMessage(failureCount, warningCount, key, outputFile);
 
                 getLog().debug("PMD failureCount: " + failureCount + ", warningCount: " + warningCount);
 
                 if (failureCount > getMaxAllowedViolations() && isFailOnViolation()) {
                     throw new MojoFailureException(message);
                 }
 
                 this.getLog().info(message);
 
                 if (failureCount > 0 && isFailOnViolation() && failureCount <= getMaxAllowedViolations()) {
                     this.getLog()
                             .info("The build is not failed, since " + getMaxAllowedViolations()
                                     + " violations are allowed (maxAllowedViolations).");
                 }
             } catch (final IOException | XmlPullParserException e) {
                 throw new MojoExecutionException("Unable to read PMD results xml: " + outputFile.getAbsolutePath(), e);
             }
         } else {
             throw new MojoFailureException("Unable to perform check, " + "unable to find " + outputFile);
         }
     }
 
     /**
      * Method for collecting the violations found by the PMD tool
      *
      * @param analysisFile
      * @param failurePriority
      * @return an int that specifies the number of violations found
      * @throws XmlPullParserException
      * @throws IOException
      */
     private ViolationDetails<D> getViolations(final File analysisFile, final int failurePriority)
             throws XmlPullParserException, IOException {
         final List<D> failures = new ArrayList<>();
         final List<D> warnings = new ArrayList<>();
 
         final List<D> violations = getErrorDetails(analysisFile);
 
         for (final D violation : violations) {
             final int priority = getPriority(violation);
             if (priority <= failurePriority && !excludeFromFile.isExcludedFromFailure(violation)) {
                 failures.add(violation);
                 if (printFailingErrors) {
                     printError(violation, "Failure");
                 }
             } else {
                 warnings.add(violation);
             }
         }
 
         final ViolationDetails<D> details = newViolationDetailsInstance();
         details.setFailureDetails(failures);
         details.setWarningDetails(warnings);
         return details;
     }
 
     protected abstract int getPriority(D errorDetail);
 
     protected abstract ViolationDetails<D> newViolationDetailsInstance();
 
     /**
      * Prints the warnings and failures
      *
      * @param failures list of failures
      * @param warnings list of warnings
      */
     protected void printErrors(final List<D> failures, final List<D> warnings) {
         for (final D warning : warnings) {
             printError(warning, "Warning");
         }
 
         for (final D failure : failures) {
             printError(failure, "Failure");
         }
     }
 
     /**
      * Gets the output message
      *
      * @param failureCount
      * @param warningCount
      * @param key
      * @param outputFile
      * @return
      */
     private String getMessage(final int failureCount, final int warningCount, final String key, final File outputFile) {
         final StringBuilder message = new StringBuilder(256);
         if (failureCount > 0 || warningCount > 0) {
             if (failureCount > 0) {
                 message.append("You have ")
                         .append(failureCount)
                         .append(" ")
                         .append(key)
                         .append(failureCount > 1 ? "s" : "");
             }
 
             if (warningCount > 0) {
                 if (failureCount > 0) {
                     message.append(" and ");
                 } else {
                     message.append("You have ");
                 }
                 message.append(warningCount).append(" warning").append(warningCount > 1 ? "s" : "");
             }
 
             message.append(". For more details see: ").append(outputFile.getAbsolutePath());
         }
         return message.toString();
     }
 
     /**
      * Formats the failure details and prints them as an INFO message
      *
      * @param item either a {@link org.apache.maven.plugins.pmd.model.Violation} from PMD
      * or a {@link org.apache.maven.plugins.pmd.model.Duplication} from CPD
      * @param severity the found issue is prefixed with the given severity, usually "Warning" or "Failure".
      */
     protected abstract void printError(D item, String severity);
 
     /**
      * Gets the attributes and text for the violation tag and puts them in a HashMap
      *
      * @param analysisFile the xml output from PMD or CPD
      * @return all PMD {@link org.apache.maven.plugins.pmd.model.Violation}s
      * or CPD {@link org.apache.maven.plugins.pmd.model.Duplication}s.
      * @throws XmlPullParserException if the analysis file contains invalid XML
      * @throws IOException if the analysis file could be read
      */
     protected abstract List<D> getErrorDetails(File analysisFile) throws XmlPullParserException, IOException;
 
     public boolean isFailOnViolation() {
         return failOnViolation;
     }
 
     public Integer getMaxAllowedViolations() {
         return maxAllowedViolations;
     }
 
     protected boolean isAggregator() {
         // returning here aggregate for backwards compatibility
         return aggregate;
     }
 }