/*
 * Copyright 2023-2024 the original author or authors.
 *
 * 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
 *
 *     https://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 rife.bld.extension;

import rife.bld.BaseProject;
import rife.bld.operations.AbstractProcessOperation;
import rife.bld.operations.exceptions.ExitStatusException;

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Mutation testing and coverage with <a href="https://pitest.org">PIT</a>.
 *
 * @author <a href="https://erik.thauvin.net/">Erik C. Thauvin</a>
 * @since 1.0
 */
public class PitestOperation extends AbstractProcessOperation<PitestOperation> {
    /**
     * False constant.
     */
    protected static final String FALSE = "false";
    /**
     * True constant.
     */
    protected static final String TRUE = "true";
    private static final Logger LOGGER = Logger.getLogger(PitestOperation.class.getName());
    private static final String SOURCE_DIRS = "--sourceDirs";
    private final Map<String, String> options_ = new ConcurrentHashMap<>();
    private BaseProject project_;

    /**
     * Line arguments for child JVMs.
     *
     * @param line the line arguments
     * @return this operation instance
     */
    public PitestOperation argLine(String line) {
        if (isNotBlank(line)) {
            options_.put("--argLine", line);
        }
        return this;
    }


    /**
     * List of packages and classes which are to be considered outside the scope of mutation. Any lines of code
     * containing calls to these classes will not be mutated.
     * <p>
     * If a list is not explicitly supplied then PIT will default to a list of common logging packages as follows
     * <p>
     * <ul>
     * <li>java.util.logging</li>
     * <li>org.apache.log4j</li>
     * <li>org.slf4j</li>
     * <li>org.apache.commons.logging</li>
     * </ul>
     * <p>
     * If the feature {@code FLOGCALL} is disabled, this parameter is ignored and logging calls are also mutated.
     *
     * @param avoidCallsTo the list of packages
     * @return this operation instance
     * @see #avoidCallsTo(String...)
     */
    public PitestOperation avoidCallsTo(Collection<String> avoidCallsTo) {
        options_.put("--avoidCallsTo", String.join(",", avoidCallsTo.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of packages and classes which are to be considered outside the scope of mutation. Any lines of code
     * containing calls to these classes will not be mutated.
     * <p>
     * If a list is not explicitly supplied then PIT will default to a list of common logging packages as follows
     * <p>
     * <ul>
     * <li>java.util.logging</li>
     * <li>org.apache.log4j</li>
     * <li>org.slf4j</li>
     * <li>org.apache.commons.logging</li>
     * </ul>
     * <p>
     * If the feature {@code FLOGCALL} is disabled, this parameter is ignored and logging calls are also mutated.
     *
     * @param avoidCallTo one or more packages
     * @return this operation instance
     * @see #avoidCallsTo(Collection)
     */
    public PitestOperation avoidCallsTo(String... avoidCallTo) {
        return avoidCallsTo(List.of(avoidCallTo));
    }

    /**
     * List of packages and classes which are to be considered outside the scope of mutation. Any lines of code
     * containing calls to these classes will not be mutated.
     * <p>
     * If a list is not explicitly supplied then PIT will default to a list of common logging packages as follows
     * <p>
     * <ul>
     * <li>java.util.logging</li>
     * <li>org.apache.log4j</li>
     * <li>org.slf4j</li>
     * <li>org.apache.commons.logging</li>
     * </ul>
     * <p>
     * If the feature {@code FLOGCALL} is disabled, this parameter is ignored and logging calls are also mutated.
     * Additional classpath entries to use when looking for tests and mutable code.
     *
     * @param path one or more paths
     * @return this operation instance
     * @see #classPath(Collection)
     */
    public PitestOperation classPath(String... path) {
        return classPath(List.of(path));
    }

    /**
     * List of packages and classes which are to be considered outside the scope of mutation. Any lines of code
     * containing calls to these classes will not be mutated.
     * <p>
     * If a list is not explicitly supplied then PIT will default to a list of common logging packages as follows
     * <p>
     * <ul>
     * <li>java.util.logging</li>
     * <li>org.apache.log4j</li>
     * <li>org.slf4j</li>
     * <li>org.apache.commons.logging</li>
     * </ul>
     * <p>
     * If the feature {@code FLOGCALL} is disabled, this parameter is ignored and logging calls are also mutated.
     * Additional classpath entries to use when looking for tests and mutable code.
     *
     * @param path one or more paths
     * @return this operation instance
     * @see #classPathPaths(Collection)
     */
    public PitestOperation classPath(Path... path) {
        return classPathPaths(List.of(path));
    }

    /**
     * Additional classpath entries to use when looking for tests and mutable code.
     *
     * @param path the list of paths
     * @return this operation instance
     * @see #classPath(String...)
     */
    public PitestOperation classPath(Collection<String> path) {
        options_.put("--classPath", String.join(",", path.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of packages and classes which are to be considered outside the scope of mutation. Any lines of code
     * containing calls to these classes will not be mutated.
     * <p>
     * If a list is not explicitly supplied then PIT will default to a list of common logging packages as follows
     * <p>
     * <ul>
     * <li>java.util.logging</li>
     * <li>org.apache.log4j</li>
     * <li>org.slf4j</li>
     * <li>org.apache.commons.logging</li>
     * </ul>
     * <p>
     * If the feature {@code FLOGCALL} is disabled, this parameter is ignored and logging calls are also mutated.
     * Additional classpath entries to use when looking for tests and mutable code.
     *
     * @param path one or more paths
     * @return this operation instance
     * @see #classPathFiles(Collection)
     */
    public PitestOperation classPath(File... path) {
        return classPathFiles(List.of(path));
    }

    /**
     * File with a list of additional classpath elements (one per line).
     *
     * @param file the file
     * @return this operation instance
     */
    public PitestOperation classPathFile(String file) {
        if (isNotBlank(file)) {
            options_.put("--classPathFile", file);
        }
        return this;
    }

    /**
     * Additional classpath entries to use when looking for tests and mutable code.
     *
     * @param path the list of paths
     * @return this operation instance
     * @see #classPath(File...)
     */
    public PitestOperation classPathFiles(Collection<File> path) {
        return classPath(path.stream().map(File::getAbsolutePath).toList());
    }

    /**
     * Additional classpath entries to use when looking for tests and mutable code.
     *
     * @param path the list of paths
     * @return this operation instance
     * @see #classPath(Path...)
     */
    public PitestOperation classPathPaths(Collection<Path> path) {
        return classPath(path.stream().map(Path::toFile).map(File::getAbsolutePath).toList());
    }

    /**
     * Line coverage threshold below which the build will fail. This is an integer percent (0-100) that represents the
     * fraction of the project covered by the tests.
     *
     * @param threshold the threshold
     * @return this operation instance
     */
    public PitestOperation coverageThreshold(int threshold) {
        if (threshold >= 0 && threshold <= 100) {
            options_.put("--coverageThreshold", String.valueOf(threshold));
        }
        return this;
    }

    /**
     * Flag to indicate if PIT should attempt to detect the inlined code generated by the java compiler in order to
     * implement {@code finally} blocks. Each copy of the inlined code would normally be mutated separately, resulting
     * in multiple identical looking mutations. When inlined code detection is enabled PIT will attempt to spot inlined
     * code and create only a single mutation that mutates all affected instructions simultaneously.
     * <p>
     * The algorithm cannot easily distinguish between inlined copies of code, and genuine duplicate instructions on
     * the same line within a {@code finally} block.
     * <p>
     * In the case of any doubt PIT will act cautiously and assume that the code is not inlined.
     * <p>
     * This will be detected as two separate inlined instructions
     * <pre>
     * finally {
     *   int++;
     *   int++;
     * }
     * </pre>
     * But this will look confusing so PIT will assume no in-lining is taking place.
     * <pre>
     * finally {
     * &nbsp;&nbsp;int++; int++;
     * }
     * </pre>
     * This sort of pattern might not be common with integer addition, but things like string concatenation are likely
     * to produce multiple similar instructions on the same line.
     * <p>
     * Defaults to {@code true}
     *
     * @param isDetectInlinedCode {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation detectInlinedCode(boolean isDetectInlinedCode) {
        if (isDetectInlinedCode) {
            options_.put("--detectInlinedCode", TRUE);
        } else {
            options_.put("--detectInlinedCode", FALSE);
        }
        return this;
    }

    /**
     * List of globs to match against class names. Matching classes will be excluded from mutation.
     *
     * @param excludedClass the excluded classws
     * @return this operation instance
     * @see #excludedClasses(Collection)
     */
    public PitestOperation excludedClasses(String... excludedClass) {
        return excludedClasses(List.of(excludedClass));
    }

    /**
     * List of globs to match against class names. Matching classes will be excluded from mutation.
     *
     * @param excludedClasses the excluded classes
     * @return this operation instance
     * @see #excludedClasses(String...)
     */
    public PitestOperation excludedClasses(Collection<String> excludedClasses) {
        options_.put("--excludedClasses", String.join(",", excludedClasses.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of TestNG groups/JUnit categories to include in mutation analysis. Note that only class level categories
     * are supported.
     *
     * @param excludedGroup one or more excluded groups
     * @return this operation instance
     * @see #excludedGroups(Collection)
     */
    public PitestOperation excludedGroups(String... excludedGroup) {
        return excludedGroups(List.of(excludedGroup));
    }

    /**
     * List of TestNG groups/JUnit categories to include in mutation analysis. Note that only class level categories
     * are supported.
     *
     * @param excludedGroups the excluded groups
     * @return this operation instance
     * @see #excludedGroups(String...)
     */
    public PitestOperation excludedGroups(Collection<String> excludedGroups) {
        options_.put("--excludedGroups", String.join(",", excludedGroups.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of globs to match against method names. Methods matching the globs will be excluded from mutation.
     *
     * @param excludedMethod one or more excluded methods
     * @return this operation instance
     * @see #excludedMethods(Collection)
     */
    public PitestOperation excludedMethods(String... excludedMethod) {
        return excludedMethods(List.of(excludedMethod));
    }

    /**
     * List of globs to match against method names. Methods matching the globs will be excluded from mutation.
     *
     * @param excludedMethods the excluded methods
     * @return this operation instance
     * @see #excludedMethods(String...)
     */
    public PitestOperation excludedMethods(Collection<String> excludedMethods) {
        options_.put("--excludedMethods",
                String.join(",", excludedMethods.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * JUnit4 runners to exclude.
     *
     * @param runners the runners
     * @return this operation instance
     */
    public PitestOperation excludedRunners(String runners) {
        options_.put("--excludedRunners", runners);
        return this;
    }

    /**
     * List of globs to match against test class names. Matching tests will not be run (note if a test suite includes
     * an excluded class, then it will “leak” back in).
     *
     * @param testClasses one or more excluded tests
     * @return this operation instance
     * @see #excludedTestClasses(Collection)
     */
    public PitestOperation excludedTestClasses(String... testClasses) {
        return excludedTestClasses(List.of(testClasses));
    }

    /**
     * List of globs to match against test class names. Matching tests will not be run (note if a test suite includes
     * an excluded class, then it will “leak” back in).
     *
     * @param testClasses the excluded tests
     * @return this operation instance
     * @see #excludedTestClasses(String...)
     */
    public PitestOperation excludedTestClasses(Collection<String> testClasses) {
        options_.put("--excludedTestClasses",
                String.join(",", testClasses.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    @Override
    public void execute() throws IOException, InterruptedException, ExitStatusException {
        if (project_ == null) {
            if (LOGGER.isLoggable(Level.SEVERE) && !silent()) {
                LOGGER.severe("A project must be specified.");
            }
            throw new ExitStatusException(ExitStatusException.EXIT_FAILURE);
        } else {
            super.execute();
        }
    }

    /**
     * Part of the {@link #execute} operation, constructs the command list
     * to use for building the process.
     */
    @Override
    protected List<String> executeConstructProcessCommandList() {
        final List<String> args = new ArrayList<>();

        if (project_ != null) {
            args.add(javaTool());
            args.add("-cp");
            args.add(String.format("%s:%s:%s:%s", new File(project_.libTestDirectory(), "*"),
                    new File(project_.libCompileDirectory(), "*"), project_.buildMainDirectory(),
                    project_.buildTestDirectory()));
            args.add("org.pitest.mutationtest.commandline.MutationCoverageReport");

            if (!options_.containsKey(SOURCE_DIRS)) {
                options_.put(SOURCE_DIRS, project_.srcDirectory().getPath());
            }

            options_.forEach((k, v) -> {
                args.add(k);
                if (!v.isEmpty()) {
                    args.add(v);
                }
            });
        }

        return args;
    }

    /**
     * Configures the operation from a {@link BaseProject}.
     *
     * @param project the project to configure the operation from
     * @since 1.5
     */
    @Override
    public PitestOperation fromProject(BaseProject project) {
        project_ = project;
        return this;
    }

    /**
     * Whether or not to dump per test line coverage data to disk.
     * <p>
     * Defaults to {@code false}
     *
     * @param jsExport {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation exportLineCoverage(boolean jsExport) {
        if (jsExport) {
            options_.put("--exportLineCoverage", TRUE);
        } else {
            options_.put("--exportLineCoverage", FALSE);
        }
        return this;
    }

    /**
     * Whether to throw an error when no mutations found.
     * <p>
     * Defaults to {@code true}
     *
     * @param isFail {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation failWhenNoMutations(boolean isFail) {
        if (isFail) {
            options_.put("--failWhenNoMutations", TRUE);
        } else {
            options_.put("--failWhenNoMutations", FALSE);
        }
        return this;
    }

    /**
     * List of features to enable/disable
     *
     * @param feature the list of features
     * @return this operation instance
     * @see #features(String...)
     */
    public PitestOperation features(Collection<String> feature) {
        options_.put("--features", String.join(",", feature.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of features to enable/disable
     *
     * @param feature one or more features
     * @return this operation instance
     * @see #features(Collection)
     */
    public PitestOperation features(String... feature) {
        return features(List.of(feature));
    }

    /**
     * Whether to create a full mutation matrix
     *
     * @param isFullMutationMatrix {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation fullMutationMatrix(boolean isFullMutationMatrix) {
        if (isFullMutationMatrix) {
            options_.put("--fullMutationMatrix", TRUE);
        } else {
            options_.put("--fullMutationMatrix", FALSE);
        }
        return this;
    }

    /**
     * Path to a file containing history information for incremental analysis.
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation historyInputLocation(String path) {
        if (isNotBlank(path)) {
            options_.put("--historyInputLocation", path);
        }
        return this;
    }

    /**
     * Path to a file containing history information for incremental analysis.
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation historyInputLocation(File path) {
        return historyInputLocation(path.getAbsolutePath());
    }

    /**
     * Path to a file containing history information for incremental analysis.
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation historyInputLocation(Path path) {
        return historyInputLocation(path.toFile());
    }

    /**
     * Path to write history information for incremental analysis. May be the same as
     * {@link #historyInputLocation(String)
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation historyOutputLocation(String path) {
        if (isNotBlank(path)) {
            options_.put("--historyOutputLocation", path);
        }
        return this;
    }

    /**
     * Path to write history information for incremental analysis. May be the same as
     * {@link #historyInputLocation(String)
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation historyOutputLocation(File path) {
        return historyOutputLocation(path.getAbsolutePath());
    }

    /**
     * Path to write history information for incremental analysis. May be the same as
     * {@link #historyInputLocation(String)
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation historyOutputLocation(Path path) {
        return historyOutputLocation(path.toFile());
    }

    /**
     * Indicates if the PIT should try to mutate classes on the classpath with which it was launched. If not supplied
     * this flag defaults to {@code true}. If set to {@code false} only classes found on the paths specified by the
     * {@link #classPath(String...) classPath}
     * <p>
     * Defaults to {@code true}
     *
     * @param isLaunchClasspath {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation includeLaunchClasspath(boolean isLaunchClasspath) {
        if (isLaunchClasspath) {
            options_.put("--includeLaunchClasspath", TRUE);
        } else {
            options_.put("--includeLaunchClasspath", FALSE);
        }
        return this;
    }

    /**
     * list of TestNG groups/JUnit categories to include in mutation analysis. Note that only class level categories
     * are supported.
     *
     * @param includedGroup one or more included groups
     * @return this operation instance
     * @see #includedGroups(Collection)
     */
    public PitestOperation includedGroups(String... includedGroup) {
        return includedGroups(List.of(includedGroup));
    }

    /**
     * list of TestNG groups/JUnit categories to include in mutation analysis. Note that only class level categories are
     * supported.
     *
     * @param includedGroups the list of included groups
     * @return this operation instance
     * @see #includedGroups(String...)
     */
    public PitestOperation includedGroups(Collection<String> includedGroups) {
        options_.put("--includedGroups", String.join(",", includedGroups.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * Test methods that should be included for challenging the mutants.
     *
     * @param testMethod the test method
     * @return this operation instance
     */
    public PitestOperation includedTestMethods(String testMethod) {
        options_.put("--includedTestMethods", testMethod);
        return this;
    }

    /**
     * Input encoding.
     * <p>
     * Default is {@code UTF-8}.
     *
     * @param encoding the encoding
     * @return this operation instance
     */
    public PitestOperation inputEncoding(String encoding) {
        if (isNotBlank(encoding)) {
            options_.put("--inputEncoding", encoding);
        }
        return this;
    }

    /*
     * Determines if a string is not blank.
     */
    private boolean isNotBlank(String s) {
        return s != null && !s.isBlank();
    }

    /**
     * Argument string to use when PIT launches child processes. This is most commonly used to increase the amount of
     * memory available to the process, but may be used to pass any valid JVM argument.
     *
     * @param args one or moe args
     * @return this operation instance
     * @see #jvmArgs(Collection)
     */
    public PitestOperation jvmArgs(String... args) {
        return jvmArgs(List.of(args));
    }

    /**
     * Argument string to use when PIT launches child processes. This is most commonly used to increase the amount of
     * memory available to the process, but may be used to pass any valid JVM argument.
     *
     * @param args the list of args
     * @return this operation instance
     * @see #jvmArgs(String...)
     */
    public PitestOperation jvmArgs(Collection<String> args) {
        options_.put("--jvmArgs", String.join(",", args.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * The path to the java executable to be used to launch test with. If none is supplied defaults to the one
     * pointed to by {@code JAVA_HOME}.
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation jvmPath(String path) {
        if (isNotBlank(path)) {
            options_.put("--jvmPath", path);
        }
        return this;
    }

    /**
     * The path to the java executable to be used to launch test with. If none is supplied defaults to the one
     * pointed to by {@code JAVA_HOME}.
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation jvmPath(File path) {
        return jvmPath(path.getAbsolutePath());
    }

    /**
     * The path to the java executable to be used to launch test with. If none is supplied defaults to the one
     * pointed to by {@code JAVA_HOME}.
     *
     * @param path the path
     * @return this operation instance
     */
    public PitestOperation jvmPath(Path path) {
        return jvmPath(path.toFile());
    }

    /**
     * Maximum number of surviving mutants to allow without throwing an error.
     *
     * @param maxMutationsPerClass the max number
     * @return this operation instance
     */
    public PitestOperation maxMutationsPerClass(int maxMutationsPerClass) {
        options_.put("--maxMutationsPerClass", String.valueOf(maxMutationsPerClass));
        return this;
    }

    /**
     * Maximum number of surviving mutants to allow without throwing an error.
     *
     * @param maxSurviving the maximin number
     * @return this operation instance
     */
    public PitestOperation maxSurviving(int maxSurviving) {
        options_.put("--maxSurviving", String.valueOf(maxSurviving));
        return this;
    }

    /**
     * List of classpaths which should be considered to contain mutable code. If your build maintains separate output
     * directories for tests and production classes this parameter should be set to your code output directory in order
     * to avoid mutating test helper classes etc.
     * <p>
     * If no mutableCodePath is supplied PIT will default to considering anything not defined within a jar or zip file
     * as being a candidate for mutation.
     * <p>
     * PIT will always attempt not to mutate test classes even if they are defined on a mutable path.
     *
     * @param path one or one paths
     * @return this operation instance
     * @see #mutableCodePaths(Collection)
     */
    public PitestOperation mutableCodePaths(String... path) {
        return mutableCodePaths(List.of(path));
    }

    /**
     * List of classpaths which should be considered to contain mutable code. If your build maintains separate output
     * directories for tests and production classes this parameter should be set to your code output directory in order
     * to avoid mutating test helper classes etc.
     * <p>
     * If no mutableCodePath is supplied PIT will default to considering anything not defined within a jar or zip file
     * as being a candidate for mutation.
     * <p>
     * PIT will always attempt not to mutate test classes even if they are defined on a mutable path.
     *
     * @param path one or one paths
     * @return this operation instance
     * @see #mutableCodePathsPaths(Collection)
     */
    public PitestOperation mutableCodePaths(Path... path) {
        return mutableCodePathsPaths(List.of(path));
    }

    /**
     * List of classpaths which should be considered to contain mutable code. If your build maintains separate output
     * directories for tests and production classes this parameter should be set to your code output directory in order
     * to avoid mutating test helper classes etc.
     * <p>
     * If no mutableCodePath is supplied PIT will default to considering anything not defined within a jar or zip file
     * as being a candidate for mutation.
     * <p>
     * PIT will always attempt not to mutate test classes even if they are defined on a mutable path.
     *
     * @param path one or one paths
     * @return this operation instance
     * @see #mutableCodePathsFiles(Collection)
     */
    public PitestOperation mutableCodePaths(File... path) {
        return mutableCodePathsFiles(List.of(path));
    }

    /**
     * List of classpaths which should be considered to contain mutable code. If your build maintains separate output
     * directories for tests and production classes this parameter should be set to your code output directory in order
     * to avoid mutating test helper classes etc.
     * <p>
     * If no mutableCodePath is supplied PIT will default to considering anything not defined within a jar or zip file
     * as being a candidate for mutation.
     * <p>
     * PIT will always attempt not to mutate test classes even if they are defined on a mutable path.
     *
     * @param paths the list of paths
     * @return this operation instance
     * @see #mutableCodePaths(String...)
     */
    public PitestOperation mutableCodePaths(Collection<String> paths) {
        options_.put("--mutableCodePaths", String.join(",", paths.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of classpaths which should be considered to contain mutable code. If your build maintains separate output
     * directories for tests and production classes this parameter should be set to your code output directory in order
     * to avoid mutating test helper classes etc.
     * <p>
     * If no mutableCodePath is supplied PIT will default to considering anything not defined within a jar or zip file
     * as being a candidate for mutation.
     * <p>
     * PIT will always attempt not to mutate test classes even if they are defined on a mutable path.
     *
     * @param paths the list of paths
     * @return this operation instance
     * @see #mutableCodePaths(File...)
     */
    public PitestOperation mutableCodePathsFiles(Collection<File> paths) {
        return mutableCodePaths(paths.stream().map(File::getAbsolutePath).toList());
    }

    /**
     * List of classpaths which should be considered to contain mutable code. If your build maintains separate output
     * directories for tests and production classes this parameter should be set to your code output directory in order
     * to avoid mutating test helper classes etc.
     * <p>
     * If no mutableCodePath is supplied PIT will default to considering anything not defined within a jar or zip file
     * as being a candidate for mutation.
     * <p>
     * PIT will always attempt not to mutate test classes even if they are defined on a mutable path.
     *
     * @param paths the list of paths
     * @return this operation instance
     * @see #mutableCodePaths(Path...)
     */
    public PitestOperation mutableCodePathsPaths(Collection<Path> paths) {
        return mutableCodePaths(paths.stream().map(Path::toFile).map(File::getAbsolutePath).toList());
    }

    /**
     * Mutation engine to use.
     * <p>
     * Defaults to {@code gregor}
     *
     * @param engine the engine
     * @return this operation instance
     */
    public PitestOperation mutationEngine(String engine) {
        options_.put("--mutationEngine", engine);
        return this;
    }

    /**
     * Mutation score threshold below which the build will fail. This is an integer percent (0-100) that represents the
     * fraction of killed mutations out of all mutations.
     * <p>
     * Please bear in mind that your build may contain equivalent mutations. Careful thought must therefore be given
     * when selecting a threshold.
     *
     * @param threshold the threshold
     * @return this operation instance
     */
    public PitestOperation mutationThreshold(int threshold) {
        if (threshold >= 0 && threshold <= 100) {
            options_.put("--mutationThreshold", String.valueOf(threshold));
        }
        return this;
    }

    /**
     * Maximum number of mutations to include.
     *
     * @param size the size
     * @return this operation instance
     */
    public PitestOperation mutationUnitSize(int size) {
        options_.put("--mutationUnitSize", String.valueOf(size));
        return this;
    }

    /**
     * List of mutation operators.
     *
     * @param mutator one or more mutators
     * @return this operation instance
     * @see #mutators(Collection)
     */
    public PitestOperation mutators(String... mutator) {
        options_.put("--mutators", String.join(",", Arrays.stream(mutator).filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * List of mutation operators.
     *
     * @param mutators the list of mutators
     * @return this operation instance
     * @see #mutators(String...)
     */
    public PitestOperation mutators(Collection<String> mutators) {
        options_.put("--mutators", String.join(",", mutators.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * Returns the PIT options.
     *
     * @return the map of options
     */
    public Map<String, String> options() {
        return options_;
    }

    /**
     * Output encoding.
     * <p>
     * Default is {@code UTF-8}.
     *
     * @param encoding the encoding
     * @return this operation instance
     */
    public PitestOperation outputEncoding(String encoding) {
        if (isNotBlank(encoding)) {
            options_.put("--outputEncoding", encoding);
        }
        return this;
    }

    /**
     * A list of formats in which to write mutation results as the mutations are analysed.
     * Supported formats are {@code HTML}, {@code XML}, {@code CSV}.
     * <p>
     * Defaults to {@code HTML}.
     *
     * @param outputFormat one or more output formats
     * @return this operation instance
     * @see #outputFormatsFiles(Collection)
     */
    public PitestOperation outputFormats(File... outputFormat) {
        return outputFormatsFiles(List.of(outputFormat));
    }

    /**
     * A list of formats in which to write mutation results as the mutations are analysed.
     * Supported formats are {@code HTML}, {@code XML}, {@code CSV}.
     * <p>
     * Defaults to {@code HTML}.
     *
     * @param outputFormat one or more output formats
     * @return this operation instance
     * @see #outputFormatsPaths(Collection)
     */
    public PitestOperation outputFormats(Path... outputFormat) {
        return outputFormatsPaths(List.of(outputFormat));
    }

    /**
     * A list of formats in which to write mutation results as the mutations are analysed.
     * Supported formats are {@code HTML}, {@code XML}, {@code CSV}.
     * <p>
     * Defaults to {@code HTML}.
     *
     * @param outputFormat one or more output formats
     * @return this operation instance
     * @see #outputFormats(Collection)
     */
    public PitestOperation outputFormats(String... outputFormat) {
        return outputFormats(List.of(outputFormat));
    }

    /**
     * A list of formats in which to write mutation results as the mutations are analysed.
     * Supported formats are {@code HTML}, {@code XML}, {@code CSV}.
     * <p>
     * Defaults to {@code HTML}.
     *
     * @param outputFormats the list of output formats
     * @return this operation instance
     * @see #outputFormats(String...)
     */
    public PitestOperation outputFormats(Collection<String> outputFormats) {
        options_.put("--outputFormats", String.join(",", outputFormats.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * A list of formats in which to write mutation results as the mutations are analysed.
     * Supported formats are {@code HTML}, {@code XML}, {@code CSV}.
     * <p>
     * Defaults to {@code HTML}.
     *
     * @param outputFormats the list of output formats
     * @return this operation instance
     * @see #outputFormats(File...)
     */
    public PitestOperation outputFormatsFiles(Collection<File> outputFormats) {
        return outputFormats(outputFormats.stream().map(File::getAbsolutePath).toList());
    }

    /**
     * A list of formats in which to write mutation results as the mutations are analysed.
     * Supported formats are {@code HTML}, {@code XML}, {@code CSV}.
     * <p>
     * Defaults to {@code HTML}.
     *
     * @param outputFormats the list of output formats
     * @return this operation instance
     * @see #outputFormats(Path...)
     */
    public PitestOperation outputFormatsPaths(Collection<Path> outputFormats) {
        return outputFormats(outputFormats.stream().map(Path::toFile).map(File::getAbsolutePath).toList());

    }

    /**
     * Custom plugin properties.
     *
     * @param key   the key
     * @param value the value
     * @return this operation instance
     */
    public PitestOperation pluginConfiguration(String key, String value) {
        options_.put("--pluginConfiguration", key + '=' + value);
        return this;
    }

    /**
     * Project base.
     *
     * @param file the file
     * @return this operations instance
     */
    public PitestOperation projectBase(String file) {
        options_.put("--projectBase", file);
        return this;
    }

    /**
     * Project base.
     *
     * @param file the file
     * @return this operations instance
     */
    public PitestOperation projectBase(File file) {
        return projectBase(file.getAbsolutePath());
    }

    /**
     * Project base.
     *
     * @param file the file
     * @return this operations instance
     */
    public PitestOperation projectBase(Path file) {
        return projectBase(file.toFile());
    }


    /**
     * Output directory for the reports.
     *
     * @param dir the directory
     * @return this operation instance
     */
    public PitestOperation reportDir(String dir) {
        if (isNotBlank(dir)) {
            options_.put("--reportDir", dir);
        }
        return this;
    }

    /**
     * Output directory for the reports.
     *
     * @param dir the directory
     * @return this operation instance
     */
    public PitestOperation reportDir(File dir) {
        return reportDir(dir.getAbsolutePath());
    }

    /**
     * Output directory for the reports.
     *
     * @param dir the directory
     * @return this operation instance
     */
    public PitestOperation reportDir(Path dir) {
        return reportDir(dir.toFile());
    }

    /**
     * whether to ignore failing tests when computing coverage.
     * <p>
     * Default is {@code false}
     *
     * @param isSkipFail {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation skipFailingTests(boolean isSkipFail) {
        if (isSkipFail) {
            options_.put("--skipFailingTests", TRUE);
        } else {
            options_.put("--skipFailingTests", FALSE);
        }
        return this;
    }

    /**
     * The folder(s) containing the source code.
     *
     * @param dir one or more directories
     * @return this operation instance
     * @see #sourceDirs(Collection)
     */
    public PitestOperation sourceDirs(String... dir) {
        return sourceDirs(List.of(dir));
    }

    /**
     * The folder(s) containing the source code.
     *
     * @param dir one or more directories
     * @return this operation instance
     * @see #sourceDirsFiles(Collection)
     */
    public PitestOperation sourceDirs(File... dir) {
        return sourceDirsFiles(List.of(dir));
    }

    /**
     * The folder(s) containing the source code.
     *
     * @param dir one or more directories
     * @return this operation instance
     * @see #sourceDirsPaths(Collection)
     */
    public PitestOperation sourceDirs(Path... dir) {
        return sourceDirsPaths(List.of(dir));
    }

    /**
     * The folder(s) containing the source code.
     *
     * @param dirs the list of directories
     * @return this operation instance
     * @see #sourceDirs(String...)
     */
    public PitestOperation sourceDirs(Collection<String> dirs) {
        options_.put(SOURCE_DIRS, String.join(",", dirs.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * The folder(s) containing the source code.
     *
     * @param dirs the list of directories
     * @return this operation instance
     * @see #sourceDirs(File...)
     */
    public PitestOperation sourceDirsFiles(Collection<File> dirs) {
        return sourceDirs(dirs.stream().map(File::getAbsolutePath).toList());
    }

    /**
     * The folder(s) containing the source code.
     *
     * @param dirs the list of directories
     * @return this operation instance
     * @see #sourceDirs(Path...)
     */
    public PitestOperation sourceDirsPaths(Collection<Path> dirs) {
        return sourceDirs(dirs.stream().map(Path::toFile).map(File::getAbsolutePath).toList());

    }

    /**
     * The classes to be mutated. This is expressed as a list of globs.
     * <p>
     * For example:
     * <p><ul>
     * <li>{@code com.myompany.*}</li>
     * <li>{@code com.mycompany.package.*, com.mycompany.packageB.Foo, com.partner.*}</li>
     * </ul></p>
     *
     * @param targetClass the list of target classes
     * @return this operation instance
     * @see #targetClasses(Collection)
     */
    public PitestOperation targetClasses(Collection<String> targetClass) {
        options_.put("--targetClasses", String.join(",", targetClass.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * The classes to be mutated. This is expressed as a list of globs.
     * <p>
     * For example:
     * <p><ul>
     * <li>{@code com.myompany.*}</li>
     * <li>{@code com.mycompany.package.*, com.mycompany.packageB.Foo, com.partner.*}</li>
     * </ul></p>
     *
     * @param targetClass one or more target classes
     * @return this operation instance
     * @see #targetClasses(String...)
     */
    public PitestOperation targetClasses(String... targetClass) {
        return targetClasses(List.of(targetClass));
    }

    /**
     * A list of globs can be supplied to this parameter to limit the tests available to be run.
     * If this parameter is not supplied then any test fixture that matched targetClasses may be used, it is however
     * recommended that this parameter is always explicitly set.
     * <p>
     * This parameter can be used to point PIT to a top level suite or suites. Custom suites such as
     * <a href="https://github.com/takari/takari-cpsuite"></a>ClassPathSuite</a> are supported.
     *
     * @param test one or more tests
     * @return this operation instance
     * @see #targetTests(Collection)
     */
    public PitestOperation targetTests(String... test) {
        return targetTests(List.of(test));
    }

    /**
     * A list of globs can be supplied to this parameter to limit the tests available to be run.
     * If this parameter is not supplied then any test fixture that matched targetClasses may be used, it is however
     * recommended that this parameter is always explicitly set.
     * <p>
     * This parameter can be used to point PIT to a top level suite or suites. Custom suites such as
     * <a href="https://github.com/takari/takari-cpsuite"></a>ClassPathSuite</a> are supported.
     *
     * @param tests the list of tests
     * @return this operation instance
     * @see #targetTests(String...)
     */
    public PitestOperation targetTests(Collection<String> tests) {
        options_.put("--targetTests", String.join(",", tests.stream().filter(this::isNotBlank).toList()));
        return this;
    }

    /**
     * Test strength score below which to throw an error.
     *
     * @param threshold the threshold
     * @return this operation instance
     */
    public PitestOperation testStrengthThreshold(int threshold) {
        options_.put("--testStrengthThreshold", String.valueOf(threshold));
        return this;
    }

    /**
     * The number of threads to use when mutation testing.
     *
     * @param threads the threads count
     * @return this operation instance
     */
    public PitestOperation threads(int threads) {
        options_.put("--threads", String.valueOf(threads));
        return this;
    }

    /**
     * Constant amount of additional time to allow a test to run for (after the application of the timeoutFactor)
     * before considering it to be stuck in an infinite loop.
     * <p>
     * Defaults to {@code 4000}
     *
     * @param factor the factor amount
     * @return this operation instance
     */
    public PitestOperation timeoutConst(int factor) {
        options_.put("--timeoutConst", String.valueOf(factor));
        return this;
    }

    /**
     * A factor to apply to the normal runtime of a test when considering if it is stuck in an infinite loop.
     * <p>
     * Defaults to {@code 1.25}
     *
     * @param factor the factor
     * @return this operation instance
     */
    public PitestOperation timeoutFactor(double factor) {
        options_.put("--timeoutFactor", String.valueOf(factor));
        return this;
    }

    /**
     * By default, PIT will create a date and time stamped folder for its output each time it is run. This can can make
     * automation difficult, so the behaviour can be suppressed by passing {@code false}.
     * <p>
     * Defaults to {@code false}
     *
     * @param isTimestamped {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation timestampedReports(boolean isTimestamped) {
        if (isTimestamped) {
            options_.put("--timestampedReports", TRUE);
        } else {
            options_.put("--timestampedReports", FALSE);
        }
        return this;
    }

    /**
     * Support large classpaths by creating a classpath jar.
     * <p>
     * Defaults to {@code false}
     *
     * @param isUseClasspathJar {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation useClasspathJar(boolean isUseClasspathJar) {
        if (isUseClasspathJar) {
            options_.put("--useClasspathJar", TRUE);
        } else {
            options_.put("--useClasspathJar", FALSE);
        }
        return this;
    }

    /**
     * Output verbose logging.
     * <p>
     * Defaults to {@code false}
     *
     * @param isVerbose {@code true} or {@code false}
     * @return this operation instance
     */
    public PitestOperation verbose(boolean isVerbose) {
        if (isVerbose) {
            options_.put("--verbose", TRUE);
        } else {
            options_.put("--verbose", FALSE);
        }
        return this;
    }

    /**
     * The verbosity of output.
     * <p>
     * Defaults to {@code DEFAULT}
     *
     * @param verbosity the verbosity
     * @return this operation instance
     */
    public PitestOperation verbosity(String verbosity) {
        options_.put("--verbosity", verbosity);
        return this;
    }
}