/*
    * 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.exec;
  
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Objects;
  
  import net.sourceforge.pmd.PMDConfiguration;
  import net.sourceforge.pmd.PmdAnalysis;
  import net.sourceforge.pmd.benchmark.TextTimingReportRenderer;
  import net.sourceforge.pmd.benchmark.TimeTracker;
  import net.sourceforge.pmd.benchmark.TimingReport;
  import net.sourceforge.pmd.benchmark.TimingReportRenderer;
  import net.sourceforge.pmd.lang.Language;
  import net.sourceforge.pmd.lang.LanguageVersion;
  import net.sourceforge.pmd.lang.rule.RulePriority;
  import net.sourceforge.pmd.lang.rule.RuleSetLoadException;
  import net.sourceforge.pmd.lang.rule.RuleSetLoader;
  import net.sourceforge.pmd.renderers.CSVRenderer;
  import net.sourceforge.pmd.renderers.HTMLRenderer;
  import net.sourceforge.pmd.renderers.Renderer;
  import net.sourceforge.pmd.renderers.TextRenderer;
  import net.sourceforge.pmd.renderers.XMLRenderer;
  import net.sourceforge.pmd.reporting.Report;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugins.pmd.ExcludeViolationsFromFile;
  import org.apache.maven.reporting.MavenReportException;
  import org.codehaus.plexus.util.FileUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Executes PMD with the configuration provided via {@link PmdRequest}.
   */
  public class PmdExecutor extends Executor {
      private static final Logger LOG = LoggerFactory.getLogger(PmdExecutor.class);
  
      public static PmdResult execute(PmdRequest request) throws MavenReportException {
          if (request.getJavaExecutable() != null) {
              return fork(request);
          }
  
          // make sure the class loaders are correct and call this in the same JVM
          ClassLoader origLoader = Thread.currentThread().getContextClassLoader();
          try {
              Thread.currentThread().setContextClassLoader(PmdExecutor.class.getClassLoader());
              PmdExecutor executor = new PmdExecutor(request);
              return executor.run();
          } finally {
              Thread.currentThread().setContextClassLoader(origLoader);
          }
      }
  
      private static PmdResult fork(PmdRequest request) throws MavenReportException {
          File basePmdDir = new File(request.getTargetDirectory(), "pmd");
          basePmdDir.mkdirs();
          File pmdRequestFile = new File(basePmdDir, "pmdrequest.bin");
          try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(pmdRequestFile))) {
              out.writeObject(request);
          } catch (IOException e) {
              throw new MavenReportException(e.getMessage(), e);
          }
  
          String classpath = buildClasspath();
          ProcessBuilder pb = new ProcessBuilder();
          // note: using env variable instead of -cp cli arg to avoid length limitations under Windows
          pb.environment().put("CLASSPATH", classpath);
          pb.command().add(request.getJavaExecutable());
          pb.command().add(PmdExecutor.class.getName());
          pb.command().add(pmdRequestFile.getAbsolutePath());
  
          LOG.debug("Executing: CLASSPATH={}, command={}", classpath, pb.command());
         try {
             final Process p = pb.start();
             // Note: can't use pb.inheritIO(), since System.out/System.err has been modified after process start
             // and inheritIO would only inherit file handles, not the changed streams.
             ProcessStreamHandler.start(p.getInputStream(), System.out);
             ProcessStreamHandler.start(p.getErrorStream(), System.err);
             int exit = p.waitFor();
             LOG.debug("PmdExecutor exit code: {}", exit);
             if (exit != 0) {
                 throw new MavenReportException("PmdExecutor exited with exit code " + exit);
             }
             return new PmdResult(new File(request.getTargetDirectory(), "pmd.xml"), request.getOutputEncoding());
         } catch (IOException e) {
             throw new MavenReportException(e.getMessage(), e);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
             throw new MavenReportException(e.getMessage(), e);
         }
     }
 
     /**
      * Execute PMD analysis from CLI.
      *
      * <p>
      * Single arg with the filename to the serialized {@link PmdRequest}.
      *
      * <p>
      * Exit-code: 0 = success, 1 = failure in executing
      *
      * @param args
      */
     public static void main(String[] args) {
         File requestFile = new File(args[0]);
         try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(requestFile))) {
             PmdRequest request = (PmdRequest) in.readObject();
             PmdExecutor pmdExecutor = new PmdExecutor(request);
             pmdExecutor.setupLogLevel(request.getLogLevel());
             pmdExecutor.run();
             System.exit(0);
         } catch (IOException | ClassNotFoundException | MavenReportException e) {
             LOG.error(e.getMessage(), e);
         }
         System.exit(1);
     }
 
     private final PmdRequest request;
 
     public PmdExecutor(PmdRequest request) {
         this.request = Objects.requireNonNull(request);
     }
 
     private PmdResult run() throws MavenReportException {
         PMDConfiguration configuration = new PMDConfiguration();
         LanguageVersion languageVersion = null;
         Language language = configuration
                 .getLanguageRegistry()
                 .getLanguageById(request.getLanguage() != null ? request.getLanguage() : "java");
         if (language == null) {
             throw new MavenReportException("Unsupported language: " + request.getLanguage());
         }
         if (request.getLanguageVersion() != null) {
             languageVersion = language.getVersion(request.getLanguageVersion());
             if (languageVersion == null) {
                 throw new MavenReportException("Unsupported targetJdk value '" + request.getLanguageVersion() + "'.");
             }
         } else {
             languageVersion = language.getDefaultVersion();
         }
         LOG.debug("Using language " + languageVersion);
         configuration.setDefaultLanguageVersion(languageVersion);
 
         if (request.getSourceEncoding() != null) {
             configuration.setSourceEncoding(Charset.forName(request.getSourceEncoding()));
         }
 
         configuration.prependAuxClasspath(request.getAuxClasspath());
 
         if (request.getSuppressMarker() != null) {
             configuration.setSuppressMarker(request.getSuppressMarker());
         }
         if (request.getAnalysisCacheLocation() != null) {
             configuration.setAnalysisCacheLocation(request.getAnalysisCacheLocation());
             LOG.debug("Using analysis cache location: " + request.getAnalysisCacheLocation());
         } else {
             configuration.setIgnoreIncrementalAnalysis(true);
         }
 
         configuration.setRuleSets(request.getRulesets());
         configuration.setMinimumPriority(RulePriority.valueOf(request.getMinimumPriority()));
         if (request.getBenchmarkOutputLocation() != null) {
             TimeTracker.startGlobalTracking();
         }
         List<File> files = request.getFiles();
 
         Report report = null;
 
         if (request.getRulesets().isEmpty()) {
             LOG.debug("Skipping PMD execution as no rulesets are defined.");
         } else {
             if (request.getBenchmarkOutputLocation() != null) {
                 TimeTracker.startGlobalTracking();
             }
 
             try {
                 report = processFilesWithPMD(configuration, files);
             } finally {
                 if (request.getAuxClasspath() != null) {
                     ClassLoader classLoader = configuration.getClassLoader();
                     if (classLoader instanceof Closeable) {
                         Closeable closeable = (Closeable) classLoader;
                         try {
                             closeable.close();
                         } catch (IOException ex) {
                             // ignore
                         }
                     }
                 }
                 if (request.getBenchmarkOutputLocation() != null) {
                     TimingReport timingReport = TimeTracker.stopGlobalTracking();
                     writeBenchmarkReport(
                             timingReport, request.getBenchmarkOutputLocation(), request.getOutputEncoding());
                 }
             }
         }
 
         if (report != null && !report.getProcessingErrors().isEmpty()) {
             List<Report.ProcessingError> errors = report.getProcessingErrors();
             if (!request.isSkipPmdError()) {
                 LOG.error("PMD processing errors:");
                 LOG.error(getErrorsAsString(errors, request.isDebugEnabled()));
                 throw new MavenReportException("Found " + errors.size() + " PMD processing errors");
             }
             LOG.warn("There are {} PMD processing errors:", errors.size());
             LOG.warn(getErrorsAsString(errors, request.isDebugEnabled()));
         }
 
         report = removeExcludedViolations(report);
         // always write XML report, as this might be needed by the check mojo
         // we need to output it even if the file list is empty or we have no violations
         // so the "check" goals can check for violations
         try {
             writeXmlReport(report);
         } catch (IOException e) {
             throw new MavenReportException("Failed to write XML report", e);
         }
 
         // write any other format except for xml and html. xml has just been produced.
         // html format is produced by the maven site formatter. Excluding html here
         // avoids using PMD's own html formatter, which doesn't fit into the maven site
         // considering the html/css styling
         String format = request.getFormat();
         if (!"html".equals(format) && !"xml".equals(format)) {
             try {
                 writeFormattedReport(report);
             } catch (IOException e) {
                 throw new MavenReportException("Failed to write formatted " + format + " report", e);
             }
         }
 
         return new PmdResult(new File(request.getTargetDirectory(), "pmd.xml"), request.getOutputEncoding());
     }
 
     /**
      * Gets the errors as a single string. Each error is in its own line.
      * @param withDetails if <code>true</code> then add the error details additionally (contains e.g. the stacktrace)
      * @return the errors as string
      */
     private String getErrorsAsString(List<Report.ProcessingError> errors, boolean withDetails) {
         List<String> errorsAsString = new ArrayList<>(errors.size());
         for (Report.ProcessingError error : errors) {
             errorsAsString.add(error.getFileId().getAbsolutePath() + ": " + error.getMsg());
             if (withDetails) {
                 errorsAsString.add(error.getDetail());
             }
         }
         return String.join(System.lineSeparator(), errorsAsString);
     }
 
     private void writeBenchmarkReport(TimingReport timingReport, String benchmarkOutputLocation, String encoding) {
         try (Writer writer = new OutputStreamWriter(new FileOutputStream(benchmarkOutputLocation), encoding)) {
             final TimingReportRenderer renderer = new TextTimingReportRenderer();
             renderer.render(timingReport, writer);
         } catch (IOException e) {
             LOG.error("Unable to generate benchmark file: {}", benchmarkOutputLocation, e);
         }
     }
 
     private Report processFilesWithPMD(PMDConfiguration pmdConfiguration, List<File> files)
             throws MavenReportException {
         Report report = null;
         RuleSetLoader rulesetLoader =
                 RuleSetLoader.fromPmdConfig(pmdConfiguration).warnDeprecated(true);
         try {
             // load the ruleset once to log out any deprecated rules as warnings
             rulesetLoader.loadFromResources(pmdConfiguration.getRuleSetPaths());
         } catch (RuleSetLoadException e1) {
             throw new MavenReportException("The ruleset could not be loaded", e1);
         }
 
         try (PmdAnalysis pmdAnalysis = PmdAnalysis.create(pmdConfiguration)) {
             for (File file : files) {
                 pmdAnalysis.files().addFile(file.toPath());
             }
             LOG.debug("Executing PMD...");
             report = pmdAnalysis.performAnalysisAndCollectReport();
             LOG.debug(
                     "PMD finished. Found {} violations.", report.getViolations().size());
         } catch (Exception e) {
             String message = "Failure executing PMD: " + e.getLocalizedMessage();
             if (!request.isSkipPmdError()) {
                 throw new MavenReportException(message, e);
             }
             LOG.warn(message, e);
         }
         return report;
     }
 
     /**
      * Use the PMD XML renderer to create the XML report format used by the
      * check mojo later on.
      *
      * @param report
      * @throws MavenReportException
      */
     private void writeXmlReport(Report report) throws IOException {
         File targetFile = writeReport(report, new XMLRenderer(request.getOutputEncoding()));
         if (request.isIncludeXmlInReports()) {
             File outputDirectory = new File(request.getReportOutputDirectory());
             if (!outputDirectory.exists() && !outputDirectory.mkdirs()) {
                 throw new IOException("Couldn't create report output directory: " + outputDirectory);
             }
             FileUtils.copyFile(targetFile, new File(outputDirectory, "pmd.xml"));
         }
     }
 
     private File writeReport(Report report, Renderer r) throws IOException {
         if (r == null) {
             return null;
         }
 
         File targetDir = new File(request.getTargetDirectory());
         if (!targetDir.exists() && !targetDir.mkdirs()) {
             throw new IOException("Couldn't create report target directory: " + targetDir);
         }
 
         String extension = r.defaultFileExtension();
         File targetFile = new File(targetDir, "pmd." + extension);
         try (Writer writer = new OutputStreamWriter(new FileOutputStream(targetFile), request.getOutputEncoding())) {
             r.setWriter(writer);
             r.start();
             if (report != null) {
                 r.renderFileReport(report);
             }
             r.end();
             r.flush();
         }
 
         return targetFile;
     }
 
     /**
      * Use the PMD renderers to render in any format aside from HTML and XML.
      *
      * @param report
      * @throws MavenReportException
      */
     private void writeFormattedReport(Report report) throws IOException, MavenReportException {
         Renderer renderer = createRenderer(request.getFormat(), request.getOutputEncoding());
         writeReport(report, renderer);
     }
 
     /**
      * Create and return the correct renderer for the output type.
      *
      * @return the renderer based on the configured output
      * @throws org.apache.maven.reporting.MavenReportException
      *             if no renderer found for the output type
      */
     public static Renderer createRenderer(String format, String outputEncoding) throws MavenReportException {
         LOG.debug("Renderer requested: {}", format);
         Renderer result = null;
         if ("xml".equals(format)) {
             result = new XMLRenderer(outputEncoding);
         } else if ("txt".equals(format)) {
             result = new TextRenderer();
         } else if ("csv".equals(format)) {
             result = new CSVRenderer();
         } else if ("html".equals(format)) {
             result = new HTMLRenderer();
         } else if (!"".equals(format) && !"none".equals(format)) {
             try {
                 result = (Renderer) Class.forName(format).getConstructor().newInstance();
             } catch (Exception e) {
                 throw new MavenReportException(
                         "Can't find PMD custom format " + format + ": "
                                 + e.getClass().getName(),
                         e);
             }
         }
 
         return result;
     }
 
     private Report removeExcludedViolations(Report report) throws MavenReportException {
         if (report == null) {
             return null;
         }
 
         ExcludeViolationsFromFile excludeFromFile = new ExcludeViolationsFromFile();
 
         try {
             excludeFromFile.loadExcludeFromFailuresData(request.getExcludeFromFailureFile());
         } catch (MojoExecutionException e) {
             throw new MavenReportException("Unable to load exclusions", e);
         }
 
         LOG.debug("Removing excluded violations. Using {} configured exclusions.", excludeFromFile.countExclusions());
         int violationsBefore = report.getViolations().size();
 
         Report filtered =
                 report.filterViolations(ruleViolation -> !excludeFromFile.isExcludedFromFailure(ruleViolation));
 
         int numberOfExcludedViolations =
                 violationsBefore - filtered.getViolations().size();
         LOG.debug("Excluded {} violations.", numberOfExcludedViolations);
         return filtered;
     }
 }