/*
 * JDrupes Builder
 * Copyright (C) 2025, 2026 Michael N. Lipp
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package org.jdrupes.builder.eclipse;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Properties;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.FileTree;
import static org.jdrupes.builder.api.Intent.*;
import org.jdrupes.builder.api.MergedTestProject;
import org.jdrupes.builder.api.Project;
import org.jdrupes.builder.api.Resource;
import org.jdrupes.builder.api.ResourceRequest;
import org.jdrupes.builder.api.ResourceType;
import org.jdrupes.builder.core.AbstractGenerator;
import static org.jdrupes.builder.eclipse.EclipseTypes.*;
import org.jdrupes.builder.java.ClassTree;
import org.jdrupes.builder.java.CodeContribution;
import org.jdrupes.builder.java.JavaCompiler;
import org.jdrupes.builder.java.JavaProject;
import static org.jdrupes.builder.java.JavaTypes.*;
import org.jdrupes.builder.java.LibraryJarFile;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/// The [EclipseConfigurator] provides the resource [EclipseConfiguration]
/// and [EclipseLauncher].
/// 
/// ## Eclipse configuration
/// 
/// "The configuration" consists of the Eclipse configuration files
/// for a given project. The configurator generates the following
/// files as W3C DOM documents (for XML files) or as [Properties]
/// for a given project:
///
///   * `.project`,
///   * `.classpath`,
///   * `.settings/org.eclipse.core.resources.prefs`,
///   * `.settings/org.eclipse.core.runtime.prefs` and
///   * `.settings/org.eclipse.jdt.core.prefs`.
///
/// Each generated data structure can be post processed by a corresponding
/// `adapt` method before being written to disk. Additional resources can
/// be generated by the method [#adaptConfiguration].
///
/// Eclipse provides project nesting, but the outer project does not
/// define a namespace. This can lead to problems if you have multiple
/// (sub)projects with the same name in the workspace. The configurator
/// allows you to define an alias for the project name to avoid this
/// problem. This alias is used as Eclipse project name in all generated
/// files.
///
/// If a project is a [MergedTestProject], the configurator merges the
/// information from this test project into the configuration files of
/// its parent project. Resources that the test project depends
/// on will be added as "test only" class path resources and the folder
/// with the sources for the java compiler will be added as "test sources".
/// 
/// ### JPMS support
/// 
/// Referenced projects are added to the module-path if they provide
/// a `module-info.class`. Referenced libraries are added to the module-path
/// if [CodeContribution#isModular()] returns `true`.
/// 
/// Resources from [MergedTestProject]s are always added to the classpath.
/// This ensures maximum visibility of the classes under test. Making the
/// test project modular, i.e. adding a `module-info.java` is not supported
/// by Eclipse. It effectively merges the sources from `src/` and `test/`
/// and complains about a duplicate `module-info.java` if such a file
/// exists in the `test` folder.
/// 
/// ## Eclipse launcher
/// 
/// The [EclipseConfigurator] also generates Eclipse launch configuration
/// files (`.launch`) as [EclipseLauncher] resources. A launch configuration
/// is an XML document of type
/// `org.eclipse.jdt.launching.localJavaApplication` that contains
/// everything needed to run a Java application from within Eclipse.
///
/// A request is made via [EclipseLauncherRequest] and must specify a name
/// (the base name of the file name) and a fully qualified main class.
/// Program arguments and VM arguments are optional.
///
/// The launch configuration includes a fully resolved classpath with the
/// JRE container, the project itself, all dependent projects, and library
/// JARs (including those resolved from Maven repositories). For modular
/// projects, the module path is populated with modular project dependencies
/// and the module name is set accordingly.
///
/// The working directory is set to the Eclipse workspace location of the
/// project. Launch configurations are not generated for [MergedTestProject]s.
/// 
/// If the launch configuration already exists, the classpath, the module path
/// the arguments and the VM arguments are updated, everything else is left
/// unchanged.
/// 
@SuppressWarnings({ "PMD.TooManyMethods", "PMD.GodClass" })
public class EclipseConfigurator extends AbstractGenerator {

    /// The Constant GENERATED_BY.
    public static final String GENERATED_BY = "Generated by JDrupes Builder";
    private static DocumentBuilderFactory dbf
        = DocumentBuilderFactory.newInstance();
    private Path outputDirectory = Path.of("bin");
    private Path testOutputDirectory = Path.of("test-bin");
    private Supplier<String> eclipseAlias = () -> project().name();
    private BiConsumer<Document, Node> classpathAdaptor = (_, _) -> {
    };
    private Runnable configurationAdaptor = () -> {
    };
    private Consumer<Properties> jdtCorePrefsAdaptor = _ -> {
    };
    private Consumer<Properties> resourcesPrefsAdaptor = _ -> {
    };
    private Consumer<Properties> runtimePrefsAdaptor = _ -> {
    };
    private ProjectConfigurationAdaptor prjConfigAdaptor = (_, _, _) -> {
    };

    /// Instantiates a new eclipse configurator.
    ///
    /// @param project the project
    ///
    public EclipseConfigurator(Project project) {
        super(project);
    }

    /// return the document builder factory.
    ///
    /// @return the document builder factory
    ///
    protected DocumentBuilderFactory documentBuilderFactory() {
        return dbf;
    }

    /// Define the eclipse (alias) project name. 
    ///
    /// @param eclipseAlias the eclipse alias
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator eclipseAlias(Supplier<String> eclipseAlias) {
        this.eclipseAlias = eclipseAlias;
        return this;
    }

    /// Define the eclipse (alias) project name. 
    ///
    /// @param eclipseAlias the eclipse alias
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator eclipseAlias(String eclipseAlias) {
        this.eclipseAlias = () -> eclipseAlias;
        return this;
    }

    /// Returns the eclipse alias.
    ///
    /// @return the string
    ///
    public String eclipseAlias() {
        return eclipseAlias.get();
    }

    /// Sets the output directory (a.k.a. folder) for classes. Defaults
    /// to "`bin`". If set to `null` the configurator makes an attempt
    /// to derive the directory from the [JavaCompiler] in the same
    /// project.
    ///
    /// @param outputDirectory the output directory
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator outputDirectory(Path outputDirectory) {
        this.outputDirectory = outputDirectory;
        return this;
    }

    /// Sets the output directory (a.k.a. folder) for test classes. Defaults
    /// to "`test-bin`". If set to `null` the configurator makes an attempt
    /// to derive the directory from the [JavaCompiler] in the test
    /// project.
    ///
    /// @param outputDirectory the output directory
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator testOutputDirectory(Path outputDirectory) {
        testOutputDirectory = outputDirectory;
        return this;
    }

    /// Provides an [EclipseConfiguration] or [EclipseLauncher].
    ///
    /// @param <T> the generic type
    /// @param requested the requested
    /// @return the stream
    ///
    @Override
    protected <T extends Resource> Collection<T>
            doProvide(ResourceRequest<T> requested) {
        // Check if provided and evaluate for most special type
        if (!requested.accepts(EclipseConfigurationType)
            && !requested.accepts(EclipseLauncherType)) {
            return Collections.emptyList();
        }

        // Handle EclipseLauncher requests
        if (requested.accepts(EclipseLauncherType)) {
            return new LaunchGenerator(this).provideLauncher(requested);
        }

        if (!requested.isFor(EclipseConfigurationType)) {
            @SuppressWarnings("unchecked")
            var result = (Collection<T>) resources(of(EclipseConfigurationType))
                .toList();
            return result;
        }

        // Generate nothing for test projects.
        if (project() instanceof MergedTestProject) {
            return Collections.emptyList();
        }

        // Make sure that the directories exist.
        project().directory().resolve(".settings").toFile().mkdirs();

        // generate .project
        generateXmlFile(this::generateProjectConfiguration, ".project");

        // generate .classpath
        if (project() instanceof JavaProject) {
            generateXmlFile(this::generateClasspathConfiguration, ".classpath");
        }

        // Generate preferences
        generateResourcesPrefs();
        generateRuntimePrefs();
        if (project() instanceof JavaProject) {
            generateJdtCorePrefs();
        }

        // General overrides
        configurationAdaptor.run();

        // Create result
        @SuppressWarnings({ "unchecked" })
        var result = (Collection<T>) List.of(
            EclipseConfiguration.of(project(), eclipseAlias()));
        return result;
    }

    /// Generate an XML file from the supplied document.
    ///
    /// @param generator the generator
    /// @param name the name
    ///
    protected void generateXmlFile(Function<Document, Document> generator,
            String name) {
        try {
            var doc = dbf.newDocumentBuilder().newDocument();
            doc = generator.apply(doc);
            var transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty(
                "{http://xml.apache.org/xslt}indent-amount", "4");
            try (var out = Files
                .newBufferedWriter(project().directory().resolve(name))) {
                transformer.transform(new DOMSource(doc),
                    new StreamResult(out));
            }
        } catch (ParserConfigurationException | TransformerException
                | TransformerFactoryConfigurationError | IOException e) {
            throw new BuildException().from(this).cause(e);
        }
    }

    /// Generates the content of the `.project` file into the given document.
    ///
    /// @param doc an empty document as starting point
    /// @return the generated document
    ///
    @SuppressWarnings("PMD.AvoidDuplicateLiterals")
    protected Document generateProjectConfiguration(Document doc) {
        var prjDescr = doc.appendChild(doc.createElement("projectDescription"));
        prjDescr.appendChild(doc.createElement("name"))
            .appendChild(doc.createTextNode(eclipseAlias()));
        prjDescr.appendChild(doc.createElement("comment")).appendChild(
            doc.createTextNode(GENERATED_BY));
        prjDescr.appendChild(doc.createElement("projects"));
        var buildSpec = prjDescr.appendChild(doc.createElement("buildSpec"));
        var natures = prjDescr.appendChild(doc.createElement("natures"));
        if (project() instanceof JavaProject) {
            var cmd = buildSpec.appendChild(doc.createElement("buildCommand"));
            cmd.appendChild(doc.createElement("name")).appendChild(
                doc.createTextNode("org.eclipse.jdt.core.javabuilder"));
            cmd.appendChild(doc.createElement("arguments"));
            natures.appendChild(doc.createElement("nature")).appendChild(
                doc.createTextNode("org.eclipse.jdt.core.javanature"));
        }

        // Allow derived class to adapt the project configuration
        prjConfigAdaptor.accept(doc, buildSpec, natures);

        // Return updated document
        return doc;
    }

    /// Allow derived classes to post process the project configuration.
    ///
    @FunctionalInterface
    public interface ProjectConfigurationAdaptor {
        /// Execute the adaptor.
        ///
        /// @param doc the document
        /// @param buildSpec shortcut to the `buildSpec` element
        /// @param natures shortcut to the `natures` element
        ///
        void accept(Document doc, Node buildSpec,
                Node natures);
    }

    /// Adapt project configuration.
    ///
    /// @param adaptor the adaptor
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator adaptProjectConfiguration(
            ProjectConfigurationAdaptor adaptor) {
        prjConfigAdaptor = adaptor;
        return this;
    }

    /// Generates the content of the `.classpath` file into the given
    /// document.
    ///
    /// @param doc an empty document as starting point
    /// @return the generated document
    ///
    protected Document generateClasspathConfiguration(Document doc) {
        var isModular = project()
            .resources(of(CodeContributionType).using(Supply))
            .filter(cc -> cc instanceof ClassTree).map(cc -> (ClassTree) cc)
            .filter(cc -> cc.isModular()).findAny().isPresent();
        var classpath = doc.appendChild(doc.createElement("classpath"));
        addCompilationResources(doc, classpath, isModular, project());
        addJavaResources(doc, classpath, project());

        // Add projects
        final Set<CodeContribution> providedByProjects = new HashSet<>();
        final Set<Project> exposed = project().providers().select(Expose)
            .filter(p -> p instanceof Project).map(Project.class::cast)
            .collect(Collectors.toSet());
        project().providers().filter(p -> p instanceof Project)
            .select(Consume, Reveal, Expose, Forward)
            .toList().stream().map(Project.class::cast).forEach(p -> {
                addProject(
                    doc, classpath, providedByProjects, exposed, isModular, p);
            });

        // Add jars
        final Set<CodeContribution> exposedByProject = new HashSet<>();
        exposedByProject.addAll(project()
            .resources(of(CodeContributionType).using(Expose))
            .toList());
        project().resources(of(LibraryJarFileType)
            .using(Consume, Reveal, Expose))
            .filter(jf -> !providedByProjects.contains(jf))
            .collect(Collectors.toSet()).stream().forEach(jf -> {
                addJarFileEntry(doc, classpath, isModular, jf,
                    exposedByProject.contains(jf), false);
            });

        // Allow derived class to override
        classpathAdaptor.accept(doc, classpath);

        // Return updated document
        return doc;
    }

    @SuppressWarnings("PMD.AvoidDuplicateLiterals")
    private void addProject(Document doc, Node classpath,
            final Set<CodeContribution> providedByProject,
            final Set<Project> exposed, boolean useModules, Project project) {
        if (project instanceof MergedTestProject) {
            if (project.parentProject().get().equals(project())) {
                // Test projects contribute their resources to the
                // parent. They are always put on the classpath for
                // maximum visibility.
                addCompilationResources(doc, classpath, false, project);
                addJavaResources(doc, classpath, project);
            }
            return;
        }
        var entry = (Element) classpath
            .appendChild(doc.createElement("classpathentry"));
        entry.setAttribute("kind", "src");
        entry.setAttribute("path", "/" + refName(project));
        if (exposed.contains(project)) {
            entry.setAttribute("exported", "true");
        }
        var attributes
            = entry.appendChild(doc.createElement("attributes"));
        var attribute = (Element) attributes
            .appendChild(doc.createElement("attribute"));
        attribute.setAttribute("without_test_code", "true");

        // Check if the project is a modular project
        if (useModules
            && project.resources(of(CodeContributionType).using(Supply))
                .filter(cc -> cc instanceof ClassTree).map(cc -> (ClassTree) cc)
                .filter(cc -> cc.isModular()).findAny().isPresent()) {
            attribute = (Element) attributes
                .appendChild(doc.createElement("attribute"));
            attribute.setAttribute("name", "module");
            attribute.setAttribute("value", "true");
        }

        // Remember what we already have due to the dependency on the
        // project to avoid duplicate entries for libraries
        providedByProject.addAll(project.resources(of(CodeContributionType)
            .using(Supply, Expose)).toList());
    }

    /// Returns another project's Eclipse name for referencing it
    /// in the configuration.
    ///
    /// @param project the project
    /// @return the string
    ///
    protected String refName(Project project) {
        return project.resources(
            of(new ResourceType<EclipseConfiguration>() {})
                .using(Supply, Expose))
            .filter(c -> c.projectName().equals(project.name())).findFirst()
            .map(EclipseConfiguration::eclipseAlias).orElse(project.name());
    }

    private void addJarFileEntry(Document doc, Node classpath,
            boolean useModules, LibraryJarFile jarFile, boolean exported,
            boolean test) {
        var entry = (Element) classpath
            .appendChild(doc.createElement("classpathentry"));
        entry.setAttribute("kind", "lib");
        var jarPathName = jarFile.path().toString();
        entry.setAttribute("path", jarPathName);
        if (exported) {
            entry.setAttribute("exported", "true");
        }

        // Add attributes
        var attributes
            = (Element) entry.appendChild(doc.createElement("attributes"));
        if (useModules && jarFile.isModular()) {
            var attr = (Element) attributes
                .appendChild(doc.createElement("attribute"));
            attr.setAttribute("name", "module");
            attr.setAttribute("value", "true");
        }
        if (test) {
            var attr = (Element) attributes
                .appendChild(doc.createElement("attribute"));
            attr.setAttribute("name", "test");
            attr.setAttribute("value", "true");
        }

        // Educated guesses
        var sourcesJar
            = new File(jarPathName.replaceFirst("\\.jar$", "-sources.jar"));
        if (sourcesJar.canRead()) {
            entry.setAttribute("sourcepath", sourcesJar.getAbsolutePath());
        }
        var javadocJar = new File(
            jarPathName.replaceFirst("\\.jar$", "-javadoc.jar"));
        if (javadocJar.canRead()) {
            var attr = (Element) attributes
                .appendChild(doc.createElement("attribute"));
            attr.setAttribute("name", "javadoc_location");
            attr.setAttribute("value",
                "jar:file:" + javadocJar.getAbsolutePath() + "!/");
        }
    }

    private void addJavaResources(Document doc, Node classpath,
            Project project) {
        // TODO Generalize. Currently we assume a Java compiler exists
        // and use it to obtain the output directory for all generators
        var javaCompiler = project.providers().select(Consume, Reveal, Supply)
            .filter(p -> p instanceof JavaCompiler)
            .map(JavaCompiler.class::cast).findFirst();
        var outputDirectory = Optional.ofNullable(
            (project instanceof MergedTestProject) ? testOutputDirectory
                : this.outputDirectory)
            .or(() -> javaCompiler
                .map(jc -> project.relativize(jc.destination())));

        // Add resources
        project.providers().without(Project.class).resources(
            of(JavaResourceTreeType).using(Consume, Reveal, Supply))
            .map(FileTree::root).filter(p -> p.toFile().canRead())
            .collect(Collectors.toSet()).stream()
            .map(project::relativize).forEach(p -> {
                var entry = (Element) classpath
                    .appendChild(doc.createElement("classpathentry"));
                entry.appendChild(doc.createComment("From " + project));
                entry.setAttribute("kind", "src");
                entry.setAttribute("path", p.toString());
                if (project instanceof MergedTestProject) {
                    outputDirectory.ifPresent(o -> {
                        entry.setAttribute("output", o.toString());
                    });
                    var attr = (Element) entry
                        .appendChild(doc.createElement("attributes"))
                        .appendChild(doc.createElement("attribute"));
                    attr.setAttribute("name", "test");
                    attr.setAttribute("value", "true");
                }
            });
    }

    private void addCompilationResources(Document doc, Node classpath,
            boolean useModules, Project project) {
        // TODO Generalize. Currently we assume a Java compiler exists
        // and use it to obtain the output directory for all generators
        var javaCompiler = project.providers().select(Consume, Reveal, Supply)
            .filter(p -> p instanceof JavaCompiler)
            .map(JavaCompiler.class::cast).findFirst();
        var outputDirectory = Optional.ofNullable(
            (project instanceof MergedTestProject) ? testOutputDirectory
                : this.outputDirectory)
            .or(() -> javaCompiler
                .map(jc -> project.relativize(jc.destination())));

        // Add source trees
        project.providers().without(Project.class).resources(
            of(JavaSourceTreeType).using(Consume, Reveal, Supply))
            .map(FileTree::root).filter(p -> p.toFile().canRead())
            .map(project::relativize).forEach(p -> {
                var entry = (Element) classpath
                    .appendChild(doc.createElement("classpathentry"));
                entry.appendChild(doc.createComment("From " + project));
                entry.setAttribute("kind", "src");
                entry.setAttribute("path", p.toString());
                if (project instanceof MergedTestProject) {
                    outputDirectory.ifPresent(o -> {
                        entry.setAttribute("output", o.toString());
                    });
                    var attr = (Element) entry
                        .appendChild(doc.createElement("attributes"))
                        .appendChild(doc.createElement("attribute"));
                    attr.setAttribute("name", "test");
                    attr.setAttribute("value", "true");
                }
            });

        // For merged test project also add compile path resources
        if (project instanceof MergedTestProject) {
            project.providers().without(project.parentProject().get()).filter(
                p -> javaCompiler.map(jc -> !p.equals(jc)).orElse(true))
                .resources(
                    of(LibraryJarFileType).using(Consume, Reveal, Expose))
                .forEach(jf -> {
                    addJarFileEntry(doc, classpath, useModules, jf, false,
                        true);
                });
            return;
        }

        // For "normal projects" configure default output directory
        outputDirectory.ifPresent(o -> {
            var entry = (Element) classpath
                .appendChild(doc.createElement("classpathentry"));
            entry.setAttribute("kind", "output");
            entry.setAttribute("path", o.toString());
        });

        // Finally Add JRE
        javaCompiler.ifPresent(jc -> {
            jc.optionArgument("-target", "--target", "--release")
                .ifPresentOrElse(v -> addSpecificJre(doc, classpath, v),
                    () -> addInheritedJre(doc, classpath));
        });
    }

    private void addSpecificJre(Document doc, Node classpath,
            String version) {
        var entry = (Element) classpath
            .appendChild(doc.createElement("classpathentry"));
        entry.setAttribute("kind", "con");
        entry.setAttribute("path",
            "org.eclipse.jdt.launching.JRE_CONTAINER"
                + "/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType"
                + "/JavaSE-" + version);
        var attributes = entry.appendChild(doc.createElement("attributes"));
        var attribute
            = (Element) attributes.appendChild(doc.createElement("attribute"));
        attribute.setAttribute("name", "module");
        attribute.setAttribute("value", "true");
    }

    private void addInheritedJre(Document doc, Node classpath) {
        var entry = (Element) classpath
            .appendChild(doc.createElement("classpathentry"));
        entry.setAttribute("kind", "con");
        entry.setAttribute("path",
            "org.eclipse.jdt.launching.JRE_CONTAINER");
        var attributes = entry.appendChild(doc.createElement("attributes"));
        var attribute
            = (Element) attributes.appendChild(doc.createElement("attribute"));
        attribute.setAttribute("name", "module");
        attribute.setAttribute("value", "true");
    }

    /// Allow the user to post process the classpath configuration.
    /// The node passed to the consumer is the `classpath` element.
    ///
    /// @param adaptor the adaptor
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator
            adaptClasspathConfiguration(BiConsumer<Document, Node> adaptor) {
        classpathAdaptor = adaptor;
        return this;
    }

    /// Generate the properties for the
    /// `.settings/org.eclipse.core.resources.prefs` file.
    ///
    protected void generateResourcesPrefs() {
        var props = new Properties();
        props.setProperty("eclipse.preferences.version", "1");
        props.setProperty("encoding/<project>", "UTF-8");
        resourcesPrefsAdaptor.accept(props);
        try (var out = new FixCommentsFilter(Files.newBufferedWriter(
            project().directory().resolve(
                ".settings/org.eclipse.core.resources.prefs")),
            GENERATED_BY)) {
            props.store(out, "");
        } catch (IOException e) {
            throw new BuildException().from(this).cause(e);
        }
    }

    /// Allow the user to adapt the properties for the
    /// `.settings/org.eclipse.core.resources.prefs` file.
    ///
    /// @param adaptor the adaptor
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator
            adaptResourcePrefs(Consumer<Properties> adaptor) {
        resourcesPrefsAdaptor = adaptor;
        return this;
    }

    /// Generate the properties for the
    /// `.settings/org.eclipse.core.runtime.prefs` file.
    ///
    protected void generateRuntimePrefs() {
        var props = new Properties();
        props.setProperty("eclipse.preferences.version", "1");
        props.setProperty("line.separator", "\n");
        runtimePrefsAdaptor.accept(props);
        try (var out = new FixCommentsFilter(Files.newBufferedWriter(
            project().directory().resolve(
                ".settings/org.eclipse.core.runtime.prefs")),
            GENERATED_BY)) {
            props.store(out, "");
        } catch (IOException e) {
            throw new BuildException().from(this).cause(e);
        }
    }

    /// Allow the user to adapt the properties for the
    /// `.settings/org.eclipse.core.runtime.prefs` file.
    ///
    /// @param adaptor the adaptor
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator adaptRuntimePrefs(Consumer<Properties> adaptor) {
        runtimePrefsAdaptor = adaptor;
        return this;
    }

    /// Generate the properties for the
    /// `.settings/org.eclipse.jdt.core.prefs` file.
    ///
    protected void generateJdtCorePrefs() {
        var props = new Properties();
        props.setProperty("eclipse.preferences.version", "1");
        project().providers().select(Supply)
            .filter(p -> p instanceof JavaCompiler).map(p -> (JavaCompiler) p)
            .findFirst().ifPresent(jc -> {
                jc.optionArgument("-target", "--target", "--release")
                    .ifPresent(v -> {
                        props.setProperty("org.eclipse.jdt.core.compiler"
                            + ".codegen.targetPlatform", v);
                    });
                jc.optionArgument("-source", "--source", "--release")
                    .ifPresent(v -> {
                        props.setProperty("org.eclipse.jdt.core.compiler"
                            + ".source", v);
                        props.setProperty("org.eclipse.jdt.core.compiler"
                            + ".compliance", v);
                    });
            });
        jdtCorePrefsAdaptor.accept(props);
        try (var out = new FixCommentsFilter(Files.newBufferedWriter(
            project().directory()
                .resolve(".settings/org.eclipse.jdt.core.prefs")),
            GENERATED_BY)) {
            props.store(out, "");
        } catch (IOException e) {
            throw new BuildException().from(this).cause(e);
        }
    }

    /// Allow the user to adapt the properties for the
    /// `.settings/org.eclipse.jdt.core.prefs` file.
    ///
    /// @param adaptor the adaptor
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator adaptJdtCorePrefs(Consumer<Properties> adaptor) {
        jdtCorePrefsAdaptor = adaptor;
        return this;
    }

    /// Allow the user to add additional resources.
    ///
    /// @param adaptor the adaptor
    /// @return the eclipse configurator
    ///
    public EclipseConfigurator adaptConfiguration(Runnable adaptor) {
        configurationAdaptor = adaptor;
        return this;
    }

}