build.gradle

/*
 * PCGen build using the Gradle tool. This file specifies the core build tasks
 * and refers to other files in the code/gradle directory for additional tasks
 * for specific output.
 *
 * Developer build: gradle
 * Incremental dev build: gradle build
 * Full build: gradle all
 * Build and run all tests: gradle clean build slowtest
 * Run the data tests: gradle datatest
 * Run the character integration tests: gradle inttest
 */

// import Ant helper static values to differ system families
import org.apache.tools.ant.filters.FixCrLfFilter
import org.apache.tools.ant.taskdefs.condition.Os
import org.gradle.plugins.ide.idea.model.ProjectLibrary

/**
 * Plugins without versions are ones that are bundled with Gradle at the version
 * being used (should be through gradlew.
 */
plugins {
    id 'application'                                    // Creating application bundles
    id 'build-dashboard'                                // Produces a build report
    id 'checkstyle'                                     // Checkstyle for Java, configured further below
    id "com.github.spotbugs" version '5.2.5'           // Spotbugs for Java
    id 'java'                                           // Core java / javac
    id 'maven-publish'                                  // Publishing to Maven Central
    id 'pmd'                                            // PMD for Java, configured further below
    id 'idea'                                           // For IntelliJ IDEA users
    id "de.undercouch.download" version '5.6.0'         // Shows download percentage
    id 'edu.sc.seis.launch4j' version '3.0.6'           // Creates launch4j
    id 'com.github.ben-manes.versions' version '0.51.0' // Checks versions for plugins and dependencies
    id "com.dorongold.task-tree" version '4.0.0'        // Prints the task dependency tree
    id 'org.openjfx.javafxplugin' version '0.1.0'      // JavaFX support
    id 'org.beryx.runtime' version '1.13.1'             // Creates custom runtimes
}

/**
 * Set the version and the modules we want from JavaFX (not everything)
 */
javafx {
    version = "17"
    modules = [ 'javafx.controls', 'javafx.web', 'javafx.swing', 'javafx.fxml', 'javafx.graphics' ]

    /*
     * Check if running in intellij ide. If so bundles javafx in to jar. If not only
     * compiles so that runtime can add different platform javafx later.
     *
     * Also allows for gradle property which if true will force the single
     * platforms javafx to be bundled to create local build. Can be added in
     * command line with "-PlocalOnly=true."
     */
    if (!System.getProperty('idea.active') && !(localOnly.toBoolean())) {
        configuration = "compileOnly"
    }
}

// Set the groupId as it helps with Maven
group = 'net.sourceforge.pcgen'

// Description of this project
description = """PCGen"""

// Default task if you just run ./gradlew
defaultTasks 'build'

// Configure Java, in particular the version to test/compile/run with
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

// Define properties for the build (directories)
ext {
    // Where code gets compiled to
    binDir = "code/bin"

    // Folder where build output is primarily stored
    String buildDir = "$projectDir/build"

    // Folder where exe / jar files are placed.
    outputDir = "$projectDir/output"

    // Folder where the jres are downloaded for building releases
    jresDir = "$projectDir/jre"

    // Folder where the JavaFX mods are downloaded for building releases
    modsDir = "$projectDir/mods"

    // Installers are placed here
    releaseDir = "${buildDir}/release"
}

application {
    mainClass.set('pcgen.system.Main')
}

/*
 * Which binary repositories this build uses.
 */
repositories {
    // Maven Central as a default
    mavenCentral()

    // Use Ant Ivy Plugin to reference our own hosted repos
    // for PCGen Base and PCGen Formula JARs
    //ivy {
        // TODO Enable HTTPS (e.g., add letsencrypt) for that location
        //url "http://pcgen.sourceforge.net/mvnrepo"
        //allowInsecureProtocol = true
        //patternLayout {
            //artifact "[organisation]/jars/[artifact]-[revision].[ext]"
        //}
    //}
    ivy {
        // TODO Enable HTTPS (e.g., add letsencrypt) for that location
        name "fileRepo"
        url 'http://pc-gen.org/librepo/'
        allowInsecureProtocol = true
    }
    // Use Maven plugin to reference jboss repository as well
    maven {
        name = 'free'
        url = 'https://java.freehep.org/maven2'
    }
    maven {
        name = 'local'
        url = 'installers'
    }
    maven {
        url "https://repository.jboss.org/nexus/content/repositories/thirdparty-releases/"
    }
}

// Define the source sets for each task/module
// TODO even though we have the idea plugin, IntelliJ doesn't reference
// these source sets whether you run that task or not.
sourceSets {
    // The main build
    main {
        java {
            srcDirs 'code/src/java'
        }
        resources {
            srcDirs = ['code/src/resources']
        }
    }
    // Running regular tests
    test {
        java {
            srcDirs = ['code/src/utest', 'code/src/testcommon']
        }
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources {
            srcDirs = ['code/src/testResources']
        }
    }
    // Integration Tests
    itest {
        java {
            srcDirs = ['code/src/itest', 'code/src/testcommon']
        }
        resources {
            srcDirs = ['code/src/testResources']
        }
        compileClasspath += sourceSets.test.compileClasspath
        runtimeClasspath += sourceSets.test.runtimeClasspath
    }
    // Running Slow Tests
    slowtest {
        java {
            srcDirs = ['code/src/test', 'code/src/testcommon']
        }
        resources {
            srcDirs = ['code/src/testResources']
        }
        compileClasspath += sourceSets.test.compileClasspath
        runtimeClasspath += sourceSets.test.runtimeClasspath
    }
}

/* Copy 'master' outputsheets into different genre folders */
task copyMasterSheets(type: Copy) {
    outputs.upToDateWhen { false }

    include 'eqsheet_fantasy_std.htm'
    include 'psheet_fantasy_std.htm'
    from 'outputsheets/d20/fantasy/htmlxml'
    into 'outputsheets/d20/historical/htmlxml'

    into ('../../horror/htmlxml') {
        from 'outputsheets/d20/fantasy/htmlxml'
    }
    into ('../../sciencefiction/htmlxml') {
        from 'outputsheets/d20/fantasy/htmlxml'
    }
    into ('../../western/htmlxml') {
        from 'outputsheets/d20/fantasy/htmlxml'
    }
}

// TODO Possibly misnamed task
compileJava {
    it.dependsOn 'copyMasterSheets'
}

/*
 * Dependencies for this project.
 *
 * implementation means both compile and runtime
 * testImplementation means both compile and runtime for test phase only
 *
 * For information on the exclude group items in this section, and why these are necessary to have Eclipse properly compile PCGen, please see the following items:
 * https://bugs.openjdk.java.net/browse/JDK-8215739
 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=536928
 * https://stackoverflow.com/questions/51094274/eclipse-cant-find-xml-related-classes-after-switching-build-path-to-jdk-10/53824670#53824670
 * https://docs.gradle.org/current/userguide/dependency_downgrade_and_exclude.html
 */
dependencies {

    implementation group: 'commons-io', name: 'commons-io', version:'2.16.0'

    implementation group: 'org.springframework', name: 'spring-web', version:'6.1.11'
    implementation group: 'org.springframework', name: 'spring-beans', version:'6.1.11'
    implementation group: 'org.springframework', name: 'spring-core', version:'6.1.11'
    implementation group: 'org.apache.commons', name: 'commons-lang3', version:'3.15.0'
    implementation group: 'xalan', name: 'serializer', version: '2.7.3'
    implementation('org.apache.xmlgraphics:fop:2.9')
    {
        exclude group: 'xml-apis', module: 'xml-apis'
    }
    implementation group: 'org.apache.commons', name: 'commons-collections4', version: '4.4'
    implementation group: 'org.scijava', name: 'jep', version:'2.4.2'
    implementation group: 'org.freemarker', name: 'freemarker', version:'2.3.33'
    implementation group: 'org.jdom', name: 'jdom2', version:'2.0.6.1'
    implementation('xalan:xalan:2.7.3')
    {
        exclude group: 'xml-apis', module: 'xml-apis'
    }
    implementation group: 'net.sourceforge.argparse4j', name: 'argparse4j', version: '0.9.0'
    implementation group: 'org.xmlunit', name: 'xmlunit-core', version:'2.10.0'
    implementation group: 'org.controlsfx', name: 'controlsfx', version:'11.2.1'

    implementation group: 'net.sourceforge.pcgen', name: 'PCGen-base', version:'1.0.170'
    // The latest Base, but pcgen core would need refactoring to support it.
    //implementation group: 'net.sourceforge.pcgen', name: 'PCGen-base', version:'1.0.237'
    // Use this if you're working from your local PCGen Base
    //implementation files("../pcgen-base/PCGen-base/build/libs/PCgen-base-1.0.jar")

    implementation group: 'net.sourceforge.pcgen', name: 'PCGen-Formula', version:'1.0.200'
    // The latest Formula, but pcgen core would need refactoring to support it.
    //implementation group: 'net.sourceforge.pcgen', name: 'PCGen-Formula', version:'1.0.266'
    // Use if you're working from your local PCGen Formula
    //implementation files("../pcgen-formula/PCGen-formula/build/libs/PCgen-formula-1.0.jar")

    compileOnly group: 'org.jetbrains', name: 'annotations', version:'24.1.0'
    compileOnly group: 'com.yuvimasory', name: 'orange-extensions', version: '1.3.0'
    compileOnly group: 'com.github.spotbugs', name: 'spotbugs-annotations', version: '4.8.6'

    testImplementation group: 'org.junit.platform', name: 'junit-platform-runner', version: '1.10.3'
    testImplementation group: 'org.junit.platform', name: 'junit-platform-launcher', version: '1.10.3'
    testImplementation group: 'org.junit.jupiter', name:  'junit-jupiter-api', version: '5.10.3'
    testImplementation group: 'org.junit.jupiter', name:  'junit-jupiter-params', version: '5.10.3'
    testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.10.3'
    testImplementation group: 'org.hamcrest', name: 'hamcrest', version: '2.2'
    testImplementation group: 'org.testfx', name: 'testfx-junit5', version: '4.0.18'
    // TODO openjfx-monocle is no longer updated and chances are openjfx-monocle doesn't work with latest OpenJFX
    // https://github.com/TestFX/Monocle/issues/79
    testImplementation group: 'org.testfx', name: 'openjfx-monocle', version: 'jdk-12.0.1+2'
    constraints {
        implementation('org.openjfx:javafx-base:22.0.2')
        implementation('org.openjfx:javafx-controls:22.0.2')
        implementation('org.openjfx:javafx-graphics:22.0.2') {
            because 'Monocle uses 12.0.1+2 that does not support Mac`s ARM'
        }
    }

    testImplementation group: 'org.xmlunit', name: 'xmlunit-matchers', version:'2.10.0'
    spotbugsPlugins 'com.h3xstream.findsecbugs:findsecbugs-plugin:1.13.0'
}

// Properties to support Ant builds
ant.importBuild 'build-gradle.xml'
ant.properties['src.java.dir']="code/src/java"
ant.properties['build.classes.dir']="build/classes/java/main"

// Configuration for creating JARs from all of the plugins
configure('jar-all-plugins') {
    group = BasePlugin.BUILD_GROUP // Or use 'build'
    description = 'Create the plugin jars'
}

ext {
    classpath = ""
    configurations.runtimeClasspath.each { lib -> classpath += " libs/${lib.name} "}
}

jar {
    // Pick up some configuration to JAR up the plugins
    it.dependsOn 'jar-all-plugins'

    // If we detect duplicate JARs ignore the subsequent ones
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE

    // Create the manifest for the main JAR
    manifest {
        attributes 'Implementation-Title': 'PCGen', 'Implementation-Version': archiveVersion,
                'Main-Class': 'pcgen.system.Main', 'Class-Path': classpath
    }

    from {
        configurations.runtimeClasspath.collect { it.directory ? it : zipTree(it) }
    }
}

/**
 * Create a Java runtime built from Java modules
 */
runtime {
    options = ['--compress', '2']
    modules = [
    'jdk.httpserver',
    'java.rmi',
    'java.desktop',
    'java.xml',
    'java.sql',
    'jdk.unsupported',
    'java.prefs',
    'java.logging',
    'java.naming',
    'jdk.xml.dom',
    'jdk.unsupported.desktop',
    'java.datatransfer',
    'java.scripting',
    'jdk.jfr',
    'jdk.jsobject',
    'javafx.controls',
    'javafx.web',
    'javafx.swing',
    'javafx.fxml',
    'javafx.graphics'
    ]

    // We support Mac/Win/Linux x86-64, Mac/Linux aarch64, and Win x86-32
    targetPlatform('linux-x64', "$projectDir/jre/linux/jre_x64")
    targetPlatform('linux-aarch64', "$projectDir/jre/linux/jre_aarch64")
    targetPlatform('windows-x64', "$projectDir/jre/windows/jre_x64")
    targetPlatform('windows-x32', "$projectDir/jre/windows/jre_x32")
    targetPlatform('mac-x64', "$projectDir/jre/mac/jre_x64/Contents/Home")
    targetPlatform('mac-aarch64', "$projectDir/jre/mac/jre_aarch64/Contents/Home")

    // Use the jpackage tool that comes with Java to build native installers
    jpackage{
        installerOptions = ["--app-version", "${version.replaceAll('-SNAPSHOT', '')}", "--license-file", "${projectDir}/code/LICENSE"]

        // Get the host architecture
        def hostArchitecture = System.getProperty("os.arch")

        if (Os.isFamily(Os.FAMILY_MAC))
        {
            if (hostArchitecture == "x86_64" || hostArchitecture == "amd64") {
                targetPlatformName = 'mac-x64'
            } else if (hostArchitecture == "aarch64") {
                targetPlatformName = 'mac-aarch64'
            } else {
                targetPlatformName = 'NOT SUPPORTED'
            }
            installerOptions += ["--mac-package-identifier", "PcGen", "--mac-package-name", "PcGen"]
            resourceDir = file("${projectDir}/installers/mac-installer")
        }
        // This may seem weird but there's no LINUX family detection in the OS lib
        else if (Os.isFamily(Os.FAMILY_UNIX)) {
            if (hostArchitecture == "x86_64" || hostArchitecture == "amd64") {
                targetPlatformName = 'linux-x64'
            } else if (hostArchitecture == "aarch64") {
                targetPlatformName = 'linux-aarch64'
            } else {
                targetPlatformName = 'NOT SUPPORTED'
            }
            installerOptions += ['--linux-shortcut']
        }
        imageName = "PcGen"
    }
}

// Package up other files with the main program
tasks.jpackageImage.doLast {
    copy {
        includeEmptyDirs = false
        from "${buildDir}/install/pcgen/"
        exclude "**/*.exe"
        exclude "**/*.bat"
        exclude "pcgen"
        exclude "**/lib/**"
        if (Os.isFamily(Os.FAMILY_MAC)){
            into "build/jpackage/PcGen.app/Contents/MacOS"
        }
        else {
            into "build/jpackage/PcGen/bin"
        }
    }

    // Mac specific
    if (Os.isFamily(Os.FAMILY_MAC)){
        copy {
            from "${projectDir}/installers/mac-installer"
            include "MacDirLauncher"
            fileMode 0755
            into "${buildDir}/jpackage/PcGen.app/Contents/MacOS"
        }
        ant.replace(file: "${buildDir}/jpackage/PcGen.app/Contents/Info.plist", token: "<key>CFBundleExecutable</key>\n  <string>PcGen</string>", value: "<key>CFBundleExecutable</key>\n  <string>MacDirLauncher</string>")
    }
}

// Create the Data Convertor JAR
task converterJar(type: Jar, dependsOn: jar) {
    manifest {
        attributes 'Implementation-Title': 'PCGen Data Converter', 'Implementation-Version': archiveVersion,
                'Main-Class': 'pcgen.gui2.converter.PCGenDataConvert', 'Class-Path': 'pcgen.jar' + classpath
    }

    archiveClassifier.set('batch-convert')
    from {
        configurations.runtimeClasspath.collect { it.directory ? it : zipTree(it) }
    }

    from sourceSets.main.output
    include 'none'
}

artifacts {
    archives converterJar
}

task copyToLibs(type: Copy, dependsOn:[startScripts,distTar,distZip,installDist]) {
    mustRunAfter createExe
    into "$buildDir/libs"
    from configurations.runtimeClasspath
}

task copyToOutput(type: Copy, dependsOn: [createExe, copyToLibs, jar, converterJar]) {
    from "$buildDir/libs/pcgen-${version}.jar"
    from "$buildDir/libs/pcgen-${version}-batch-convert.jar"
    from "$buildDir/launch4j/pcgen.exe"
    from "$projectDir/code/pcgen.bat"
    from("$projectDir/code/pcgen.sh") {
        filter(FixCrLfFilter, eol:FixCrLfFilter.CrLf.newInstance("lf"))
        fileMode 0755
    }
    into outputDir

    rename "(.+)-$version(.+)", '$1$2'
}

task qbuild(type: Copy, dependsOn: [copyToOutput, jar]) {
    description="Copy the executable file into 'output' to create a working environment"
    from "$buildDir/libs/pcgen-${version}.jar"

    into outputDir

    rename "(.+)-$version(.+)", '$1$2'
    mustRunAfter clean
}

task cleanOutput(type: Delete) {
    description="Clean up things copied to the output folder by the build"
    delete outputDir
}

// TODO - Hook this into a clean phase properly
task cleanJre(type: Delete) {
    description="Clean up things copied to the jre folder by the build"
    delete jresDir
}

// TODO - Hook this into a clean phase properly
task cleanMods(type: Delete) {
    description="Clean up things copied to the mods folder by the build"
    delete modsDir
}

// Alias tasks
tasks.register("buildonly") {
    dependsOn 'copyToOutput'
}

tasks.register("quickbuild") {
    dependsOn 'copyToOutput', 'test'
}

build {
    it.dependsOn 'copyToOutput'
}

// TODO This clean is not as nuclear as it perhaps should be.
// For jlink and friends to work when you get odd Zip errors
// you will also need to clean out output/ bin/ jre/ and mods/
clean {
    it.dependsOn 'clean-plugins'
    it.dependsOn 'cleanOutput'
}

// Ensures that clean is never run after build and when clean is called it is
// run before build so it doesn't delete the new build folder.
build.mustRunAfter clean

task downloadJRE {
    def major = 17
    def archs = ['x64', 'x32', 'aarch64']
    def osList = ['windows', 'mac', 'linux']
    def extension = 'zip'

    println("Downloading JDKS for use in creating the runtime bundles.")

    osList.each{
        def os = "${it}"
        if(os != "windows") {
            extension = 'tar.gz'
        }
        archs.each {
            def arch = "${it}"
            if (arch == "x32" && os != "windows") return
            if (arch == "aarch64" && os == "windows") return

            def url = "https://api.adoptium.net/v3/binary/latest/${major}/ga/${os}/${arch}/jdk/hotspot/normal/eclipse"
            def jreDir = new File("${projectDir}/jre/${os}/jre_${arch}")
            if(!jreDir.exists()){
                println("Downloading Java ${major} ${arch} for ${os} from ${url}")
                download.run {
                    src url
                    dest new File("${projectDir}/jre/${os}/", "jre_${arch}.${extension}")
                    overwrite false
                }

                // Now unzip them
                if(extension == "zip"){
                    fileTree(dir: "${projectDir}/jre/${os}/").include("*.${extension}").each { simLib ->
                        copy {
                            println "Unzip $simLib.name"
                            def zipFile = file("${projectDir}/jre/${os}/${simLib.name}")
                            def outputDir = "${projectDir}/jre/${os}/jre_${arch}/"

                            from zipTree(zipFile)
                            into outputDir
                            eachFile { fcd ->
                                def relPath = fcd.relativePath
                                if(relPath.lastName.startsWith("jdk-")  && fcd.isDirectory()) {
                                    fcd.exclude()
                                } else {
                                    def segments = relPath.segments
                                    fcd.relativePath = new RelativePath( !fcd.isDirectory() ,(segments[1..-1]) as String[]  )
                                }
                            }
                        }
                        new File("${projectDir}/jre/${os}/${simLib.name}").delete()
                    }
                } else {
                    fileTree(dir: "${projectDir}/jre/${os}/").include("*.${extension}").each { simLib ->
                        copy {
                            println "Unzip $simLib.name"
                            def name = simLib.name - '.$extension'
                            def zipFile = file("${projectDir}/jre/${os}/${simLib.name}")
                            def outputDir = "${projectDir}/jre/${os}/jre_${arch}/"

                            from tarTree(zipFile)
                            into outputDir
                            eachFile { fcd ->
                                def relPath = fcd.relativePath
                                if(relPath.lastName.startsWith("jdk-")  && fcd.isDirectory()) {
                                    fcd.exclude()
                                } else {
                                    def segments = relPath.segments
                                    fcd.relativePath = new RelativePath( !fcd.isDirectory() ,(segments[1..-1]) as String[] )
                                }
                            }
                        }
                        new File("${projectDir}/jre/${os}/${simLib.name}").delete()
                    }
                }
                file("${projectDir}/jre/${os}/jre_${arch}").list().each { f->
                    if(f.startsWith("jdk")) {
                        file("${projectDir}/jre/${os}/jre_${arch}/"+f).deleteDir()
                    }
                }
            }
            else {
                println("Java ${major} ${arch} for ${os} already exists at ${jreDir}")
            }
        }
    }
}

task downloadJavaFXModules(dependsOn: downloadJRE) {
    // We support Windows/Mac/Linux - x64, Mac/Linux - aarch64, and Windows x86 (32-bit)
    def major = "17.0.8"
    def archs = ['x64', 'x86', 'aarch64']
    def osList = ["windows", "mac", "linux"]

    println("Downloading JavaFX modules (.mods) for use in the runtime bundles.")
    // Downloads javafx .mods for custom runtime image. All platforms downloaded
    osList.each {
        def os = "${it}"

        archs.each {
            def arch = "$it"

            // build the architecture part of the download filename string
            def archAppend
            if (arch == "x86") {
                // Only Windows for x86-32 bit
                if (os == "windows") {
                    archAppend = "-x86"
                } else {
                    return
                }
            } else if (arch == "x64") {
                archAppend = "-x64"
            } else if (arch == "aarch64") {
                // Only Linux and Mac for aarch64
                if (os != "windows") {
                    archAppend = "-aarch64"
                } else {
                    return
                }
            } else {
                archAppend = "-UNSUPPORTED-ARCHITECTURE"
            }

            // Build the os part of the filename string.
            // Gluon renamed the mac package to osx
            def osPackage = os
            if (os == "mac") {
                osPackage = "osx"
            }

            // URLs look like this: https://download2.gluonhq.com/openjfx/17.0.6/openjfx-17.0.6_osx-aarch64_bin-jmods.zip
            def url = "https://download2.gluonhq.com/openjfx/${major}/openjfx-${major}_${osPackage}${archAppend}_bin-jmods.zip"

            def jmodsZip = new File("${projectDir}/jre/${os}/jmods${arch}.zip")
            // If we don't already have the jmods, download them and unzip them
            // to the correct place.
            if (!jmodsZip.exists()) {
                println("Downloading Javafx mods ${major} ${arch} for ${os} from ${url}")
                download.run {
                    src url
                    dest new File("${projectDir}/jre/${os}/", "jmods${arch}.zip")
                    overwrite false
                }

                copy {
                    def zipFile = file("${projectDir}/jre/${os}/jmods${arch}.zip")
                    def outputDir = "${projectDir}/jre/${os}/jre_${arch}/jmods"
                    if (os == "mac")
                    {
                        outputDir = "${projectDir}/jre/${os}/jre_${arch}/Contents/Home/jmods"
                    }
                    else if(os == "windows" && arch == "x86")
                    {
                        outputDir = "${projectDir}/jre/${os}/jre_x32/jmods"
                    }
                    println "Unzipping ${zipFile} to ${outputDir}"
                    from zipTree(zipFile)
                    into outputDir
                    eachFile { fcd ->
                        def relPath = fcd.relativePath
                        def segments = relPath.segments
                        fcd.relativePath = new RelativePath(!fcd.isDirectory(), (segments[1..-1]) as String[])
                    }
                }
            } else {
                println("${jmodsZip} already exists")
            }
        }
    }

    // TODO extract this into its own function
    // Downloads javafx sdk for local platform. Used for running tests.
    println("Downloading JavaFX SDK for use in local testing.")
    def sdkDir = new File("${projectDir}/mods")
    if (!sdkDir.exists() || sdkDir.list().length == 0) {

        // TODO I'll confess much of this seems redundant, but I'm not touching it
        def os=""
        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
            os = "windows"
        } else if (Os.isFamily(Os.FAMILY_MAC)) {
            os = "mac"
        } else {
            os = "linux"
        }

        def hostArchitecture = System.getProperty("os.arch")

        // We default to x86_64 as default
        def archAppend= ""
        if (hostArchitecture == "x86_64" || hostArchitecture == "amd64") {
            archAppend= "-x64"
        } else if (hostArchitecture == "i386") {
            archAppend= "-x86" // TODO Not sure if this is supported.
        } else if (hostArchitecture == "aarch64") {
            archAppend= "-aarch64"
        } else {
            archAppend = "-UNSUPPORTED-ARCH"
        }

        println("Host arch is ${hostArchitecture}")

        // Gluon renamed the mac package so we deal with that but leave the
        // the rest of the naming / packing as 'mac'.
        def osPackage = os
        if (os == "mac") {
            osPackage = "osx"
        }

        def url = "https://download2.gluonhq.com/openjfx/${major}/openjfx-${major}_${osPackage}${archAppend}_bin-sdk.zip"

        println("Downloading JavaFX SDK for ${os} from ${url}")

        download.run {
            src url
            dest new File("${projectDir}/mods", "javaFXSdk-${os}.zip")
            overwrite false
        }

        copy {

            def zipFile = file("${projectDir}/mods/javaFXSdk-${os}.zip")
            def outputDir = "${projectDir}/mods"
            println "Unzipping ${zipFile} to ${outputDir}"

            from zipTree(zipFile)
            into outputDir
            eachFile { fcd ->
                def relPath = fcd.relativePath
                def segments = relPath.segments
                fcd.relativePath = new RelativePath(!fcd.isDirectory(), (segments[1..-1]) as String[])
            }
        }
    } else {
        println("JavaFX SDK already exists at ${sdkDir}")
    }
}

compileJava.dependsOn(downloadJavaFXModules)
tasks.runtime.dependsOn(downloadJavaFXModules)

test {
    exclude 'pcgen/testsupport/**'
    useJUnitPlatform()
}

task itest(type: Test, dependsOn: [jar]) {
    useJUnitPlatform()
    testClassesDirs = sourceSets.itest.output.classesDirs
    classpath = sourceSets.itest.runtimeClasspath
    systemProperties['jar.path'] = jar.getArchiveFile().get().getAsFile()
}

task slowtest(type: Test, dependsOn: ['jar', 'itest']) {
    useJUnitPlatform()
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    systemProperties['jar.path'] = jar.getArchiveFile().get().getAsFile()
    forkEvery = 1
    // Exclude the two suites to avoid duplicate test runs.
    exclude 'AllJUnitTests.class'
    exclude 'pcgen/core/AllJUnitTests.class'
}

task datatest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    include 'pcgen/persistence/lst/DataTest.class'
    include 'pcgen/persistence/lst/DataLoadTest.class'
}

task inttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/**/*Test.class'
}

task sfinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_starfinder/*Test.class'
}

task pfinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_pathfinder/*Test.class'
}

task rsrdinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_35e/*Test.class'
}

task srdinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_3e/*Test.class'
}

task msrdinttest(type: Test, dependsOn: 'jar') {
    testClassesDirs = sourceSets.slowtest.output.classesDirs
    classpath = sourceSets.slowtest.runtimeClasspath
    forkEvery = 1
    include 'pcgen/inttest/game_modern/*Test.class'
}

// Do the lot!  TODO reenable slowtest
task all(dependsOn: ['build', 'slowtest', 'javadoc', 'buildNsis', 'allReports']) {
//task all(dependsOn: ['build', 'javadoc', 'buildNsis', 'allReports']) {
}

allprojects {
    tasks.withType(JavaCompile).configureEach {
        options.fork = true
    }
    tasks.withType(Javadoc) {
        options.addBooleanOption('Xdoclint:none', true)
    }
    tasks.withType(Test) {
        maxHeapSize = "1024m"
        maxParallelForks = 1
        enableAssertions = true
        testLogging {
            exceptionFormat = 'full'
            events 'failed', 'skipped'
        }
        jvmArgs += [
                '-Djava.awt.headless=true',
                '-Dtestfx.robot=glass',
                '-Dtestfx.headless=true',
                '-Dprism.order=sw',
                '-Dprism.verbose=true',
                '-Djavafx.macosx.embedded=true',

                "--module-path", "${projectDir}/mods/lib/",
                "--add-modules", "javafx.controls,javafx.web,javafx.swing,javafx.fxml",

                // Needed to fix issue with testfx test crashing due to issue with modularity of whole program. Slightly related issue. https://github.com/TestFX/TestFX/issues/638
                '--add-exports', 'javafx.graphics/com.sun.javafx.application=ALL-UNNAMED',
                '--add-opens', 'javafx.graphics/com.sun.glass.ui=ALL-UNNAMED',
        ]
    }
    tasks.withType(JavaCompile) {
        doFirst {

            if (name.toLowerCase().contains("test")) {
                options.compilerArgs << "--module-path" << "${projectDir}/mods/lib/"
                options.compilerArgs << "--add-modules" << "javafx.controls,javafx.web,javafx.swing,javafx.fxml"
            }
            println "Args for for $name are $options.allCompilerArgs"
        }
    }
    // https://youtrack.jetbrains.com/issue/KT-46165
    tasks.withType(org.gradle.jvm.tasks.Jar) {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }
    tasks.withType(JavaExec) {
        maxHeapSize = "2048m"
    }
}

dependencyUpdates {
    revision='release'
}

dependencyUpdates.resolutionStrategy {
    componentSelection { rules ->
        rules.all { ComponentSelection selection ->
            if (['atlassian'].any { qualifier ->
                    selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
                }) {
                selection.reject('unofficial release')
            }
            boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'preview', 'b', 'ea'].any { qualifier ->
                selection.candidate.version ==~ /(?i).*[.-]$qualifier[.\d-+]*/
            }
            if (rejected) {
                selection.reject('Release candidate')
            }
            if (selection.candidate.version == '2.0.2' && selection.candidate.name == 'xml-apis') {
                selection.reject('older than current')
            }
            if (selection.candidate.version == '2.24' && selection.candidate.name == 'jep') {
                selection.reject('older than current')
            }
            if (selection.candidate.version == '1.8.0_20' && selection.candidate.name == 'openjfx-monocle') {
                selection.reject('older than current')
            }
        }
    }
}

// Support for creating IntelliJ IDEA files.
idea {
    project {
        def javafxLib = file("$projectDir/mods/lib")
        def files = javafxLib.listFiles( { _, name -> name.contains(".jar") } as FilenameFilter)
                .toList() // no direct way to convert from Array to Set
                .toSet()

        def projectLibrary = new ProjectLibrary()
        projectLibrary.name = "lib"
        projectLibrary.classes += files

        projectLibraries += [ projectLibrary ]
    }

    module {
        testSources.from(project.sourceSets.itest.java.srcDirs,
                project.sourceSets.slowtest.java.srcDirs)

        iml.withXml {
            def module = asNode()
            def component = module.find {it.@name == 'NewModuleRootManager'}
            def orderEntry = component.appendNode('orderEntry', [ type: 'library', scope: 'RUNTIME', name:'lib', level:'project'])
        }
    }
}

// Use the gradle wrapper
wrapper {
    distributionType = Wrapper.DistributionType.ALL
}

// Bring in the rest of the gradle build config
apply from: 'code/gradle/autobuild.gradle'
apply from: 'code/gradle/distribution.gradle'
apply from: 'code/gradle/reporting.gradle'
apply from: 'code/gradle/release.gradle'