///////////////////////////////////////////////////////////////////////////////////////////////
// checkstyle: Checks Java source code and other text files for adherence to a set of rules.
// Copyright (C) 2001-2025 the original author or authors.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
///////////////////////////////////////////////////////////////////////////////////////////////

package com.puppycrawl.tools.checkstyle.ant;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.FileScanner;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.taskdefs.LogOutputStream;
import org.apache.tools.ant.types.EnumeratedAttribute;
import org.apache.tools.ant.types.FileSet;

import com.puppycrawl.tools.checkstyle.AbstractAutomaticBean.OutputStreamOptions;
import com.puppycrawl.tools.checkstyle.Checker;
import com.puppycrawl.tools.checkstyle.ConfigurationLoader;
import com.puppycrawl.tools.checkstyle.DefaultLogger;
import com.puppycrawl.tools.checkstyle.ModuleFactory;
import com.puppycrawl.tools.checkstyle.PackageObjectFactory;
import com.puppycrawl.tools.checkstyle.PropertiesExpander;
import com.puppycrawl.tools.checkstyle.SarifLogger;
import com.puppycrawl.tools.checkstyle.ThreadModeSettings;
import com.puppycrawl.tools.checkstyle.XMLLogger;
import com.puppycrawl.tools.checkstyle.api.AuditListener;
import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
import com.puppycrawl.tools.checkstyle.api.Configuration;
import com.puppycrawl.tools.checkstyle.api.RootModule;
import com.puppycrawl.tools.checkstyle.api.SeverityLevel;
import com.puppycrawl.tools.checkstyle.api.SeverityLevelCounter;

/**
 * An implementation of an ANT task for calling checkstyle. See the documentation
 * of the task for usage.
 */
public class CheckstyleAntTask extends Task {

    /** Poor man's enum for an xml formatter. */
    private static final String E_XML = "xml";
    /** Poor man's enum for a plain formatter. */
    private static final String E_PLAIN = "plain";
    /** Poor man's enum for a sarif formatter. */
    private static final String E_SARIF = "sarif";

    /** Suffix for time string. */
    private static final String TIME_SUFFIX = " ms.";

    /** Contains the paths to process. */
    private final List<org.apache.tools.ant.types.Path> paths = new ArrayList<>();

    /** Contains the filesets to process. */
    private final List<FileSet> fileSets = new ArrayList<>();

    /** Contains the formatters to log to. */
    private final List<Formatter> formatters = new ArrayList<>();

    /** Contains the Properties to override. */
    private final List<Property> overrideProps = new ArrayList<>();

    /** Name of file to check. */
    private String fileName;

    /** Config file containing configuration. */
    private String config;

    /** Whether to fail build on violations. */
    private boolean failOnViolation = true;

    /** Property to set on violations. */
    private String failureProperty;

    /** The name of the properties file. */
    private Path properties;

    /** The maximum number of errors that are tolerated. */
    private int maxErrors;

    /** The maximum number of warnings that are tolerated. */
    private int maxWarnings = Integer.MAX_VALUE;

    /**
     * Whether to execute ignored modules - some modules may log above
     * their severity depending on their configuration (e.g. WriteTag) so
     * need to be included
     */
    private boolean executeIgnoredModules;

    ////////////////////////////////////////////////////////////////////////////
    // Setters for ANT specific attributes
    ////////////////////////////////////////////////////////////////////////////

    /**
     * Tells this task to write failure message to the named property when there
     * is a violation.
     *
     * @param propertyName the name of the property to set
     *                      in the event of a failure.
     */
    public void setFailureProperty(String propertyName) {
        failureProperty = propertyName;
    }

    /**
     * Sets flag - whether to fail if a violation is found.
     *
     * @param fail whether to fail if a violation is found
     */
    public void setFailOnViolation(boolean fail) {
        failOnViolation = fail;
    }

    /**
     * Sets the maximum number of errors allowed. Default is 0.
     *
     * @param maxErrors the maximum number of errors allowed.
     */
    public void setMaxErrors(int maxErrors) {
        this.maxErrors = maxErrors;
    }

    /**
     * Sets the maximum number of warnings allowed. Default is
     * {@link Integer#MAX_VALUE}.
     *
     * @param maxWarnings the maximum number of warnings allowed.
     */
    public void setMaxWarnings(int maxWarnings) {
        this.maxWarnings = maxWarnings;
    }

    /**
     * Adds a path.
     *
     * @param path the path to add.
     */
    public void addPath(org.apache.tools.ant.types.Path path) {
        paths.add(path);
    }

    /**
     * Adds set of files (nested fileset attribute).
     *
     * @param fileSet the file set to add
     */
    public void addFileset(FileSet fileSet) {
        fileSets.add(fileSet);
    }

    /**
     * Add a formatter.
     *
     * @param formatter the formatter to add for logging.
     */
    public void addFormatter(Formatter formatter) {
        formatters.add(formatter);
    }

    /**
     * Add an override property.
     *
     * @param property the property to add
     */
    public void addProperty(Property property) {
        overrideProps.add(property);
    }

    /**
     * Creates classpath.
     *
     * @return a created path for locating classes
     * @deprecated left in implementation until #12556 only to allow users to migrate to new gradle
     *     plugins. This method will be removed in Checkstyle 11.x.x .
     * @noinspection DeprecatedIsStillUsed
     * @noinspectionreason DeprecatedIsStillUsed - until #12556
     */
    @Deprecated(since = "10.7.0")
    public org.apache.tools.ant.types.Path createClasspath() {
        return new org.apache.tools.ant.types.Path(getProject());
    }

    /**
     * Sets file to be checked.
     *
     * @param file the file to be checked
     */
    public void setFile(File file) {
        fileName = file.getAbsolutePath();
    }

    /**
     * Sets configuration file.
     *
     * @param configuration the configuration file, URL, or resource to use
     * @throws BuildException when config was already set
     */
    public void setConfig(String configuration) {
        if (config != null) {
            throw new BuildException("Attribute 'config' has already been set");
        }
        config = configuration;
    }

    /**
     * Sets flag - whether to execute ignored modules.
     *
     * @param omit whether to execute ignored modules
     */
    public void setExecuteIgnoredModules(boolean omit) {
        executeIgnoredModules = omit;
    }

    ////////////////////////////////////////////////////////////////////////////
    // Setters for Root Module's configuration attributes
    ////////////////////////////////////////////////////////////////////////////

    /**
     * Sets a properties file for use instead
     * of individually setting them.
     *
     * @param props the properties File to use
     */
    public void setProperties(File props) {
        properties = props.toPath();
    }

    ////////////////////////////////////////////////////////////////////////////
    // The doers
    ////////////////////////////////////////////////////////////////////////////

    @Override
    public void execute() {
        final long startTime = System.currentTimeMillis();

        try {
            final String version = Objects.toString(
                    CheckstyleAntTask.class.getPackage().getImplementationVersion(),
                    "");

            log("checkstyle version " + version, Project.MSG_VERBOSE);

            // Check for no arguments
            if (fileName == null
                    && fileSets.isEmpty()
                    && paths.isEmpty()) {
                throw new BuildException(
                        "Must specify at least one of 'file' or nested 'fileset' or 'path'.",
                        getLocation());
            }
            if (config == null) {
                throw new BuildException("Must specify 'config'.", getLocation());
            }
            realExecute(version);
        }
        finally {
            final long endTime = System.currentTimeMillis();
            log("Total execution took " + (endTime - startTime) + TIME_SUFFIX,
                Project.MSG_VERBOSE);
        }
    }

    /**
     * Helper implementation to perform execution.
     *
     * @param checkstyleVersion Checkstyle compile version.
     */
    private void realExecute(String checkstyleVersion) {
        // Create the root module
        RootModule rootModule = null;
        try {
            rootModule = createRootModule();

            // setup the listeners
            final AuditListener[] listeners = getListeners();
            for (AuditListener element : listeners) {
                rootModule.addListener(element);
            }
            final SeverityLevelCounter warningCounter =
                new SeverityLevelCounter(SeverityLevel.WARNING);
            rootModule.addListener(warningCounter);

            processFiles(rootModule, warningCounter, checkstyleVersion);
        }
        finally {
            if (rootModule != null) {
                rootModule.destroy();
            }
        }
    }

    /**
     * Scans and processes files by means given root module.
     *
     * @param rootModule Root module to process files
     * @param warningCounter Root Module's counter of warnings
     * @param checkstyleVersion Checkstyle compile version
     * @throws BuildException if the files could not be processed,
     *     or if the build failed due to violations.
     */
    private void processFiles(RootModule rootModule, final SeverityLevelCounter warningCounter,
            final String checkstyleVersion) {
        final long startTime = System.currentTimeMillis();
        final List<File> files = getFilesToCheck();
        final long endTime = System.currentTimeMillis();
        log("To locate the files took " + (endTime - startTime) + TIME_SUFFIX,
            Project.MSG_VERBOSE);

        log("Running Checkstyle "
                + checkstyleVersion
                + " on " + files.size()
                + " files", Project.MSG_INFO);
        log("Using configuration " + config, Project.MSG_VERBOSE);

        final int numErrs;

        try {
            final long processingStartTime = System.currentTimeMillis();
            numErrs = rootModule.process(files);
            final long processingEndTime = System.currentTimeMillis();
            log("To process the files took " + (processingEndTime - processingStartTime)
                + TIME_SUFFIX, Project.MSG_VERBOSE);
        }
        catch (CheckstyleException exc) {
            throw new BuildException("Unable to process files: " + files, exc);
        }
        final int numWarnings = warningCounter.getCount();
        final boolean okStatus = numErrs <= maxErrors && numWarnings <= maxWarnings;

        // Handle the return status
        if (!okStatus) {
            final String failureMsg =
                    "Got " + numErrs + " errors (max allowed: " + maxErrors + ") and "
                            + numWarnings + " warnings.";
            if (failureProperty != null) {
                getProject().setProperty(failureProperty, failureMsg);
            }

            if (failOnViolation) {
                throw new BuildException(failureMsg, getLocation());
            }
        }
    }

    /**
     * Creates new instance of the root module.
     *
     * @return new instance of the root module
     * @throws BuildException if the root module could not be created.
     */
    private RootModule createRootModule() {
        final RootModule rootModule;
        try {
            final Properties props = createOverridingProperties();
            final ThreadModeSettings threadModeSettings =
                    ThreadModeSettings.SINGLE_THREAD_MODE_INSTANCE;
            final ConfigurationLoader.IgnoredModulesOptions ignoredModulesOptions;
            if (executeIgnoredModules) {
                ignoredModulesOptions = ConfigurationLoader.IgnoredModulesOptions.EXECUTE;
            }
            else {
                ignoredModulesOptions = ConfigurationLoader.IgnoredModulesOptions.OMIT;
            }

            final Configuration configuration = ConfigurationLoader.loadConfiguration(config,
                    new PropertiesExpander(props), ignoredModulesOptions, threadModeSettings);

            final ClassLoader moduleClassLoader =
                Checker.class.getClassLoader();

            final ModuleFactory factory = new PackageObjectFactory(
                    Checker.class.getPackage().getName() + ".", moduleClassLoader);

            rootModule = (RootModule) factory.createModule(configuration.getName());
            rootModule.setModuleClassLoader(moduleClassLoader);
            rootModule.configure(configuration);
        }
        catch (final CheckstyleException exc) {
            throw new BuildException(String.format(Locale.ROOT, "Unable to create Root Module: "
                    + "config {%s}.", config), exc);
        }
        return rootModule;
    }

    /**
     * Create the Properties object based on the arguments specified
     * to the ANT task.
     *
     * @return the properties for property expansion
     * @throws BuildException if the properties file could not be loaded.
     */
    private Properties createOverridingProperties() {
        final Properties returnValue = new Properties();

        // Load the properties file if specified
        if (properties != null) {
            try (InputStream inStream = Files.newInputStream(properties)) {
                returnValue.load(inStream);
            }
            catch (final IOException exc) {
                throw new BuildException("Error loading Properties file '"
                        + properties + "'", exc, getLocation());
            }
        }

        // override with Ant properties like ${basedir}
        final Map<String, Object> antProps = getProject().getProperties();
        for (Map.Entry<String, Object> entry : antProps.entrySet()) {
            final String value = String.valueOf(entry.getValue());
            returnValue.setProperty(entry.getKey(), value);
        }

        // override with properties specified in subelements
        for (Property p : overrideProps) {
            returnValue.setProperty(p.getKey(), p.getValue());
        }

        return returnValue;
    }

    /**
     * Return the array of listeners set in this task.
     *
     * @return the array of listeners.
     * @throws BuildException if the listeners could not be created.
     */
    private AuditListener[] getListeners() {
        final int formatterCount = Math.max(1, formatters.size());

        final AuditListener[] listeners = new AuditListener[formatterCount];

        // formatters
        try {
            if (formatters.isEmpty()) {
                final OutputStream debug = new LogOutputStream(this, Project.MSG_DEBUG);
                final OutputStream err = new LogOutputStream(this, Project.MSG_ERR);
                listeners[0] = new DefaultLogger(debug, OutputStreamOptions.CLOSE,
                        err, OutputStreamOptions.CLOSE);
            }
            else {
                for (int i = 0; i < formatterCount; i++) {
                    final Formatter formatter = formatters.get(i);
                    listeners[i] = formatter.createListener(this);
                }
            }
        }
        catch (IOException exc) {
            throw new BuildException(String.format(Locale.ROOT, "Unable to create listeners: "
                    + "formatters {%s}.", formatters), exc);
        }
        return listeners;
    }

    /**
     * Returns the list of files (full path name) to process.
     *
     * @return the list of files included via the fileName, filesets and paths.
     */
    private List<File> getFilesToCheck() {
        final List<File> allFiles = new ArrayList<>();
        if (fileName != null) {
            // oops, we've got an additional one to process, don't
            // forget it. No sweat, it's fully resolved via the setter.
            log("Adding standalone file for audit", Project.MSG_VERBOSE);
            allFiles.add(Path.of(fileName).toFile());
        }

        final List<File> filesFromFileSets = scanFileSets();
        allFiles.addAll(filesFromFileSets);

        final List<Path> filesFromPaths = scanPaths();
        allFiles.addAll(filesFromPaths.stream()
            .map(Path::toFile)
            .toList());

        return allFiles;
    }

    /**
     * Retrieves all files from the defined paths.
     *
     * @return a list of files defined via paths.
     */
    private List<Path> scanPaths() {
        final List<Path> allFiles = new ArrayList<>();

        for (int i = 0; i < paths.size(); i++) {
            final org.apache.tools.ant.types.Path currentPath = paths.get(i);
            final List<Path> pathFiles = scanPath(currentPath, i + 1);
            allFiles.addAll(pathFiles);
        }

        return allFiles;
    }

    /**
     * Scans the given path and retrieves all files for the given path.
     *
     * @param path      A path to scan.
     * @param pathIndex The index of the given path. Used in log messages only.
     * @return A list of files, extracted from the given path.
     */
    private List<Path> scanPath(org.apache.tools.ant.types.Path path, int pathIndex) {
        final String[] resources = path.list();
        log(pathIndex + ") Scanning path " + path, Project.MSG_VERBOSE);
        final List<Path> allFiles = new ArrayList<>();
        int concreteFilesCount = 0;

        for (String resource : resources) {
            final Path file = Path.of(resource);
            if (Files.isRegularFile(file)) {
                concreteFilesCount++;
                allFiles.add(file);
            }
            else {
                final DirectoryScanner scanner = new DirectoryScanner();
                scanner.setBasedir(file.toFile());
                scanner.scan();
                final List<Path> scannedFiles = retrieveAllScannedFiles(scanner, pathIndex);
                allFiles.addAll(scannedFiles);
            }
        }

        if (concreteFilesCount > 0) {
            log(String.format(Locale.ROOT, "%d) Adding %d files from path %s",
                pathIndex, concreteFilesCount, path), Project.MSG_VERBOSE);
        }

        return allFiles;
    }

    /**
     * Returns the list of files (full path name) to process.
     *
     * @return the list of files included via the filesets.
     */
    protected List<File> scanFileSets() {
        final List<Path> allFiles = new ArrayList<>();

        for (int i = 0; i < fileSets.size(); i++) {
            final FileSet fileSet = fileSets.get(i);
            final DirectoryScanner scanner = fileSet.getDirectoryScanner(getProject());
            final List<Path> scannedFiles = retrieveAllScannedFiles(scanner, i);
            allFiles.addAll(scannedFiles);
        }

        return allFiles.stream()
            .map(Path::toFile)
            .toList();
    }

    /**
     * Retrieves all matched files from the given scanner.
     *
     * @param scanner  A directory scanner. Note, that {@link DirectoryScanner#scan()}
     *                 must be called before calling this method.
     * @param logIndex A log entry index. Used only for log messages.
     * @return A list of files, retrieved from the given scanner.
     */
    private List<Path> retrieveAllScannedFiles(FileScanner scanner, int logIndex) {
        final String[] fileNames = scanner.getIncludedFiles();
        log(String.format(Locale.ROOT, "%d) Adding %d files from directory %s",
                logIndex, fileNames.length, scanner.getBasedir()), Project.MSG_VERBOSE);

        return Arrays.stream(fileNames)
          .map(scanner.getBasedir().toPath()::resolve)
          .toList();
    }

    /**
     * Poor man enumeration for the formatter types.
     */
    public static class FormatterType extends EnumeratedAttribute {

        /** My possible values. */
        private static final String[] VALUES = {E_XML, E_PLAIN, E_SARIF};

        @Override
        public String[] getValues() {
            return VALUES.clone();
        }

    }

    /**
     * Details about a formatter to be used.
     */
    public static class Formatter {

        /** The formatter type. */
        private FormatterType type;
        /** The file to output to. */
        private File toFile;
        /** Whether or not to write to the named file. */
        private boolean useFile = true;

        /**
         * Set the type of the formatter.
         *
         * @param type the type
         */
        public void setType(FormatterType type) {
            this.type = type;
        }

        /**
         * Set the file to output to.
         *
         * @param destination destination the file to output to
         */
        public void setTofile(File destination) {
            toFile = destination;
        }

        /**
         * Sets whether or not we write to a file if it is provided.
         *
         * @param use whether not to use provided file.
         */
        public void setUseFile(boolean use) {
            useFile = use;
        }

        /**
         * Creates a listener for the formatter.
         *
         * @param task the task running
         * @return a listener
         * @throws IOException if an error occurs
         */
        public AuditListener createListener(Task task) throws IOException {
            final AuditListener listener;
            if (type != null
                    && E_XML.equals(type.getValue())) {
                listener = createXmlLogger(task);
            }
            else if (type != null
                    && E_SARIF.equals(type.getValue())) {
                listener = createSarifLogger(task);
            }
            else {
                listener = createDefaultLogger(task);
            }
            return listener;
        }

        /**
         * Creates Sarif logger.
         *
         * @param task the task to possibly log to
         * @return an SarifLogger instance
         * @throws IOException if an error occurs
         */
        private AuditListener createSarifLogger(Task task) throws IOException {
            final AuditListener sarifLogger;
            if (toFile == null || !useFile) {
                sarifLogger = new SarifLogger(new LogOutputStream(task, Project.MSG_INFO),
                        OutputStreamOptions.CLOSE);
            }
            else {
                sarifLogger = new SarifLogger(Files.newOutputStream(toFile.toPath()),
                        OutputStreamOptions.CLOSE);
            }
            return sarifLogger;
        }

        /**
         * Creates default logger.
         *
         * @param task the task to possibly log to
         * @return a DefaultLogger instance
         * @throws IOException if an error occurs
         */
        private AuditListener createDefaultLogger(Task task)
                throws IOException {
            final AuditListener defaultLogger;
            if (toFile == null || !useFile) {
                defaultLogger = new DefaultLogger(
                    new LogOutputStream(task, Project.MSG_DEBUG),
                        OutputStreamOptions.CLOSE,
                        new LogOutputStream(task, Project.MSG_ERR),
                        OutputStreamOptions.CLOSE
                );
            }
            else {
                final OutputStream infoStream = Files.newOutputStream(toFile.toPath());
                defaultLogger =
                        new DefaultLogger(infoStream, OutputStreamOptions.CLOSE,
                                infoStream, OutputStreamOptions.NONE);
            }
            return defaultLogger;
        }

        /**
         * Creates XML logger.
         *
         * @param task the task to possibly log to
         * @return an XMLLogger instance
         * @throws IOException if an error occurs
         */
        private AuditListener createXmlLogger(Task task) throws IOException {
            final AuditListener xmlLogger;
            if (toFile == null || !useFile) {
                xmlLogger = new XMLLogger(new LogOutputStream(task, Project.MSG_INFO),
                        OutputStreamOptions.CLOSE);
            }
            else {
                xmlLogger = new XMLLogger(Files.newOutputStream(toFile.toPath()),
                        OutputStreamOptions.CLOSE);
            }
            return xmlLogger;
        }

    }

    /**
     * Represents a property that consists of a key and value.
     */
    public static class Property {

        /** The property key. */
        private String key;
        /** The property value. */
        private String value;

        /**
         * Gets key.
         *
         * @return the property key
         */
        public String getKey() {
            return key;
        }

        /**
         * Sets key.
         *
         * @param key sets the property key
         */
        public void setKey(String key) {
            this.key = key;
        }

        /**
         * Gets value.
         *
         * @return the property value
         */
        public String getValue() {
            return value;
        }

        /**
         * Sets value.
         *
         * @param value set the property value
         */
        public void setValue(String value) {
            this.value = value;
        }

        /**
         * Sets the property value from a File.
         *
         * @param file set the property value from a File
         */
        public void setFile(File file) {
            value = file.getAbsolutePath();
        }

    }

}