import de.undercouch.gradle.tasks.download.Download

plugins {
    // https://plugins.gradle.org/plugin/com.github.johnrengelman.shadow (v5 requires Gradle 5)
    id 'com.github.johnrengelman.shadow' version '6.1.0'
    // https://plugins.gradle.org/plugin/de.undercouch.download
    id "de.undercouch.download" version "4.1.1"
    id 'java'
    // https://github.com/tbroyer/gradle-errorprone-plugin
    id "net.ltgt.errorprone" version "2.0.1"
    // https://plugins.gradle.org/plugin/org.ajoberstar.grgit
    id 'org.ajoberstar.grgit' version '4.1.0' apply false
    // https://github.com/n0mer/gradle-git-properties ; target is: generateGitProperties
    id "com.gorylenko.gradle-git-properties" version "2.3.1"
}
apply plugin: "de.undercouch.download"

import org.ajoberstar.grgit.Grgit

repositories {
    jcenter()
    mavenCentral()
}

gitProperties {
    // logically belongs in framework, but only checker resources are copied to .jar file
    gitPropertiesResourceDir = file("${project.rootDir}/checker/src/main/resources")
}

ext {
    release = false

    // On a Java 8 JVM, use error-prone javac and source/target 8.
    // On a Java 9+ JVM, use the host javac, default source/target, and required module flags.
    isJava8 = JavaVersion.current() == JavaVersion.VERSION_1_8

    errorproneJavacVersion = '9+181-r4173-1'

    parentDir = file("${rootDir}/../").absolutePath

    annotationTools = "${parentDir}/annotation-tools"
    afu = "${annotationTools}/annotation-file-utilities"

    stubparser = "${parentDir}/stubparser"
    stubparserJar = "${stubparser}/javaparser-core/target/stubparser-3.20.2.1.jar"

    jtregHome = "${parentDir}/jtreg"
    formatScriptsHome = "${project(':checker').projectDir}/bin-devel/.run-google-java-format"
    plumeScriptsHome = "${project(':checker').projectDir}/bin-devel/.plume-scripts"
    htmlToolsHome = "${project(':checker').projectDir}/bin-devel/.html-tools"

    javadocMemberLevel = JavadocMemberLevel.PROTECTED

    // The local git repository, typically in the .git directory, but not for worktrees.
    // This value is always overwritten, but Gradle needs the variable to be initialized.
    localRepo = ".git"
}
// Keep in sync with check in org.checkerframework.framework.source.SourceChecker.init
// and with text in #installation
switch (JavaVersion.current()) {
    case JavaVersion.VERSION_1_9:
    case JavaVersion.VERSION_1_10:
    case JavaVersion.VERSION_12:
        logger.warn("The Checker Framework has only been tested with JDK 8 and 11." +
                " Found version " + JavaVersion.current().majorVersion);
        break;
    case JavaVersion.VERSION_1_8:
    case JavaVersion.VERSION_11:
        break; // Supported versions
    default:
        throw new GradleException("Build the Checker Framework with JDK 8 or JDK 11." +
                " Found version " + JavaVersion.current().majorVersion);
}

task setLocalRepo(type:Exec) {
    commandLine 'git', 'worktree', 'list'
    standardOutput = new ByteArrayOutputStream()
    doLast {
       String worktreeList = standardOutput.toString()
       localRepo = worktreeList.substring(0, worktreeList.indexOf(" ")) + "/.git"
    }
}

// No group so it does not show up in the output of `gradlew tasks`
task installGitHooks(type: Copy, dependsOn: 'setLocalRepo') {
    description 'Copies git hooks to .git directory'
    from files("checker/bin-devel/git.post-merge", "checker/bin-devel/git.pre-commit")
    rename('git\\.(.*)', '$1')
    into localRepo + "/hooks"
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'com.github.johnrengelman.shadow'
    apply plugin: "de.undercouch.download"
    apply plugin: 'net.ltgt.errorprone'

    group 'org.checkerframework'
    // Increment the minor version (second number) rather than just the patch
    // level (third number) if:
    //   * any new checkers have been added, or
    //   * backward-incompatible changes have been made to APIs or elsewhere.
    version '3.13.1-SNAPSHOT'

    repositories {
        mavenCentral()
    }

    configurations {
        javacJar

        // Holds the combined classpath of all subprojects including the subprojects themselves.
        allProjects

        // Exclude checker-qual dependency added by Error Prone to avoid a circular dependency.
        annotationProcessor.exclude group:'org.checkerframework', module:'checker-qual'
    }

    configurations {
        checkerFatJar
    }
    dependencies {
        if (isJava8) {
            javacJar group: 'com.google.errorprone', name: 'javac', version: "$errorproneJavacVersion"
        }

        errorproneJavac("com.google.errorprone:javac:$errorproneJavacVersion")

        allProjects subprojects
        checkerFatJar project(path: ':checker', configuration: 'shadow')
    }


    // After all the tasks have been created, modify some of them.
    afterEvaluate {
        // Add the fat checker.jar to the classpath of every Javadoc task. This allows Javadoc in
        // any module to reference classes in any other module.
        // Also, build and use ManualTaglet as a taglet.
        tasks.withType(Javadoc) {
            def tagletVersion = isJava8 ? 'taglet' : 'tagletJdk11'

            dependsOn(':checker:shadowJar')
            dependsOn(":framework-test:${tagletVersion}Classes")
            doFirst {
                options.encoding = 'UTF-8'
                if (!name.equals("javadocDoclintAll")) {
                    options.memberLevel = javadocMemberLevel
                }
                classpath += rootProject.configurations.getByName('checkerFatJar').asFileTree
                if (isJava8) {
                    classpath += configurations.javacJar
                }
                options.taglets 'org.checkerframework.taglet.ManualTaglet'
                options.tagletPath(project(':framework-test').sourceSets."${tagletVersion}".output.classesDirs.getFiles() as File[])

                // We want to link to Java 9 documentation of the compiler classes since we use Java 9
                // versions of those classes and Java 8 for everything else.  Because the compiler classes are not
                // a part of the main documentation of Java 8, javadoc links to the Java 9 versions.
                // TODO, this creates broken links to the com.sun.tools.javac package.
                options.links = ['https://docs.oracle.com/javase/8/docs/api/', 'https://docs.oracle.com/javase/9/docs/api/']
                // This file is looked for by Javadoc.
                file("${destinationDir}/resources/fonts/").mkdirs()
                ant.touch(file: "${destinationDir}/resources/fonts/dejavu.css")
                options.addStringOption('source', '8')
                // "-Xwerror" requires Javadoc everywhere.  Currently, CI jobs require Javadoc only
                // on changed lines.  Enable -Xwerror in the future when all Javadoc exists.
                // options.addBooleanOption('Xwerror', true)
                options.addStringOption('Xmaxwarns', '99999')
            }
        }

        // Add standard javac options
        tasks.withType(JavaCompile) { compilationTask ->
            dependsOn(':installGitHooks')
            // Put source files in deterministic order, for debugging.
            compilationTask.source = compilationTask.source.sort()
            sourceCompatibility = 8
            targetCompatibility = 8
            // Because the target is 8, all of the public compiler classes are accessible, so
            // --add-exports are not required, (nor are they allowed with target 8). See
            // https://openjdk.java.net/jeps/247 for details on compiling for older versions.

            // When sourceCompatibilty is changed to 11, then the following will be required.
            // options.compilerArgs += [
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
            // ]
            // This is equivalent to writing "exports jdk.compiler/... to ALL-UNNAMED" in the
            // module-info.java of jdk.compiler, so corresponding --add-opens are only required for
            // reflective access to private members.
            //
            // From https://openjdk.java.net/jeps/261, Section titled: "Breaking encapsulation"
            // "The effect of each instance [of --add-exports] is to add a qualified export of the
            // named package from the source module to the target module. This is, essentially, a
            // command-line form of an exports clause in a module declaration[...].
            // [...]
            // The --add-exports option enables access to the public types of a specified package.
            // It is sometimes necessary to go further and enable access to all non-public elements
            // via the setAccessible method of the core reflection API. The --add-opens option can
            // be used, at run time, to do this."

            options.failOnError = true
            options.deprecation = true
            options.compilerArgs += [
                    '-g',
                    '-Werror',
                    // -options: To not get a warning about missing bootstrap classpath for Java 8 (once we use Java 9).
                    // -fallthrough: Don't check fallthroughs.  Instead, use Error Prone.  Its
                    // warnings are suppressible with a "// fall through" comment.
                    "-Xlint:-options,-fallthrough",
                    "-Xlint",
            ]

            options.encoding = 'UTF-8'
            options.fork = true
            if (isJava8) {
                options.forkOptions.jvmArgs += ["-Xbootclasspath/p:${configurations.javacJar.asPath}".toString()]
            }

            // Error prone depends on checker-qual.jar, so don't run it on that project to avoid a circular dependency.
            // TODO: enable Error Prone on test classes.
            if (compilationTask.name.equals('compileJava') && !project.name.startsWith('checker-qual')) {
                // Error Prone must be available in the annotation processor path
                options.annotationProcessorPath = configurations.errorprone
                // Enable Error Prone
                options.errorprone.enabled = true
                options.errorprone.disableWarningsInGeneratedCode = true
                options.errorprone.errorproneArgs = [
                        // Many compiler classes are interned.
                        '-Xep:ReferenceEquality:OFF',
                        // These might be worth fixing.
                        '-Xep:DefaultCharset:OFF',
                        // Not useful to suggest Splitter; maybe clean up.
                        '-Xep:StringSplitter:OFF',
                        // Too broad, rejects seemingly-correct code.
                        '-Xep:EqualsGetClass:OFF',
                        // Not a real problem
                        '-Xep:MixedMutabilityReturnType:OFF',
                        // Don't want to add a dependency to ErrorProne.
                        '-Xep:AnnotateFormatMethod:OFF',
                        // Warns for every use of "@checker_framework.manual"
                        '-Xep:InvalidBlockTag:OFF',
                        // Recommends writing @InlineMe which is an Error-Prone-specific annotation
                        '-Xep:InlineMeSuggester:OFF',
                        // -Werror halts the build if Error Prone issues a warning, which ensures that
                        // the errors get fixed.  On the downside, Error Prone (or maybe the compiler?)
                        // stops as soon as it issues one warning, rather than outputting them all.
                        // https://github.com/google/error-prone/issues/436
                        '-Werror',
                ]
            } else {
                options.errorprone.enabled = false
            }
        }
    }
}

task cloneAndBuildDependencies(type: Exec, group: 'Build') {
    description 'Clones (or updates) and builds all dependencies'
    executable 'checker/bin-devel/build.sh'
}

task maybeCloneAndBuildDependencies() {
    // No group so it does not show up in the output of `gradlew tasks`
    description 'Clones (or updates) and builds all dependencies if they are not present.'
    onlyIf {
        !file(stubparserJar).exists()
        // The jdk repository is cloned via the copyAndMinimizeAnnotatedJdkFiles task that is run if
        // the repository does not exist when building checker.jar.
    }

    doFirst {
        if (file(stubparser).exists()) {
            exec {
                workingDir stubparser
                executable 'git'
                args = ['pull', '-q']
                ignoreExitValue = true
            }
            exec {
                workingDir stubparser
                executable "${stubparser}/.travis-build-without-test.sh"
            }
        } else {
            executable 'checker/bin-devel/build.sh'
        }
    }
    doLast {
        if (!file(stubparserJar).exists()) {
            exec {
                workingDir ${stubparser}/javaparser-core/target
                executable 'ls'
                ignoreExitValue = true
            }
            throw new RuntimeException("Can't find stubparser jar: " + stubparserJar)
        }
    }
}

task version(group: 'Documentation') {
    description 'Print Checker Framework version'
    doLast {
        println version
    }
}

/**
 * Creates a task that runs the checker on the main source set of each subproject. The task is named
 * "check${taskName}", for example "checkPurity" or "checkNullness".
 *
 * @param projectName name of the project
 * @param taskName short name (often the checker name) to use as part of the task name
 * @param checker fully qualified name of the checker to run
 * @param args list of arguments to pass to the checker
 */
def createCheckTypeTask(projectName, taskName, checker, args = []) {
    project("${projectName}").tasks.create(name: "check${taskName}", type: JavaCompile, dependsOn: ':checker:shadowJar') {
        description "Run the ${taskName} Checker on the main sources."
        group 'Verification'
        // Always run the task.
        outputs.upToDateWhen { false }
        source = project("${projectName}").sourceSets.main.java
        classpath = files(project("${projectName}").compileJava.classpath,project(':checker-qual').sourceSets.main.output)
        destinationDir = file("${buildDir}")

        options.annotationProcessorPath = files(project(':checker').tasks.shadowJar.archivePath)
        options.compilerArgs += [
                '-processor', "${checker}",
                '-proc:only',
                '-Xlint:-processing',
                '-Xmaxerrs', '10000',
                '-Xmaxwarns', '10000',
                '-ArequirePrefixInWarningSuppressions',
                '-AwarnUnneededSuppressions',
        ]
        options.compilerArgs += args
        options.forkOptions.jvmArgs += ["-Xmx2g"]

        if (isJava8) {
            options.compilerArgs += [
                "-source",
                "8",
                "-target",
                "8"
                ]
        } else {
            options.fork = true
            options.forkOptions.jvmArgs += [
                "--add-opens", "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
                ]
       }
    }
}

/**
 * Returns a list of all the Java files that should be formatted for the given project. These are:
 *
 * All java files in the main sourceSet.
 * All java files in the tests directory that compile.
 *
 * @param projectName name of the project to format
 * @return a list of all Java files that should be formatted for projectName
 */
List<String> getJavaFilesToFormat(projectName) {
    List<File> javaFiles = new ArrayList<>();
    project(':' + projectName).sourceSets.forEach { set ->
        javaFiles.addAll(set.java.files)
    }

    // Collect all java files in tests directory
    fileTree("${project(projectName).projectDir}/tests").visit { details ->
        // If you change this, also change checker/bin-devel/git.pre-commit
        if (!details.path.contains("nullness-javac-errors")
                && !details.path.contains("returnsreceiverdelomboked")
                && !details.path.contains("build")
                && details.name.endsWith('.java')) {
            javaFiles.add(details.file)
        }
    }

    // Collect all java files in jtreg directory
    fileTree("${project(projectName).projectDir}/jtreg").visit { details ->
        if (!details.path.contains("nullness-javac-errors") && details.name.endsWith('.java')) {
            javaFiles.add(details.file)
        }
    }

    // Collect all java files in jtregJdk11 directory
    fileTree("${project(projectName).projectDir}/jtregJdk11").visit { details ->
        if (!details.path.contains("nullness-javac-errors") && details.name.endsWith('.java')) {
            javaFiles.add(details.file)
        }
    }

    List<String> args = new ArrayList<>(javaFiles.size());
    for (File f : javaFiles) {
        args += project(projectName).relativePath(f)
    }
    return args
}

task htmlValidate(type: Exec, group: 'Format') {
    description 'Validate that HTML files are well-formed'
    executable 'html5validator'
    args = [
            "--ignore",
            "/api/",
            "/build/",
            "/docs/manual/manual.html",
            "/checker/jdk/nullness/src/java/lang/ref/package.html"
    ]
}


// `gradle allJavadoc` builds the Javadoc for all modules in `docs/api`.
//   This is what is published to checkerframework.org.
// `gradle javadoc` builds the Javadoc for each sub-project in <subproject>/build/docs/javadoc/ .
//   It's needed to create the Javadoc jars that we release in Maven Central.
// To make javadoc for only one subproject, run `./gradlew javadoc`
//   in the subproject or `./gradlew :checker:javadoc` at the top level.
task allJavadoc(type: Javadoc, group: 'Documentation') {
    description = 'Generates API documentation that includes all the modules.'
    dependsOn(':checker:shadowJar', 'getPlumeScripts', 'getHtmlTools')
    destinationDir = file("${rootDir}/docs/api")
    source(project(':checker-util').sourceSets.main.allJava, project(':checker-qual').sourceSets.main.allJava, project(':checker').sourceSets.main.allJava, project(':framework').sourceSets.main.allJava,
            project(':dataflow').sourceSets.main.allJava, project(':javacutil').sourceSets.main.allJava)

    classpath = configurations.allProjects
    if (isJava8) {
        classpath += configurations.javacJar
    }
    doLast {
        exec {
            // Javadoc for to com.sun.tools.java.* is not publicly available, so these links are broken.
            // This command removes those links.
            workingDir "${rootDir}/docs/api"
            executable "${plumeScriptsHome}/preplace"
            args += ['<a href="https://docs.oracle.com/javase/9/docs/api/com/sun/tools/javac/.*?>(.*?)</a>', '\\1']
        }
        copy {
            from 'docs/logo/Checkmark/CFCheckmark_favicon.png'
            rename('CFCheckmark_favicon.png', 'favicon-checkerframework.png')
            into "${rootDir}/docs/api"
        }
        exec {
            workingDir "${rootDir}/docs/api"
            executable "${htmlToolsHome}/html-add-favicon"
            args += ['.', 'favicon-checkerframework.png']
        }
    }
}

// See documentation for allJavadoc task.
javadoc.dependsOn(allJavadoc)

configurations {
    requireJavadoc
}
dependencies {
    requireJavadoc "org.plumelib:require-javadoc:1.0.2"
}
task requireJavadoc(type: JavaExec, group: 'Documentation') {
    description = 'Ensures that Javadoc documentation exists in source code.'
    main = "org.plumelib.javadoc.RequireJavadoc"
    classpath = configurations.requireJavadoc
    args "checker/src/main/java", "dataflow/src/main/java", "framework-test/src/main/java", "framework/src/main/java", "javacutil/src/main/java"
}


/**
 * Creates a task named taskName that runs javadoc with the -Xdoclint:all option.
 *
 * @param taskName the name of the task to create
 * @param taskDescription description of the task
 * @param memberLevel the JavadocMemberLevel to use
 * @return the new task
 */
def createJavadocTask(taskName, taskDescription, memberLevel) {
    tasks.create(name: taskName, type: Javadoc) {
        description = taskDescription
        destinationDir = file("${rootDir}/docs/tmpapi")
        destinationDir.mkdirs()
        subprojects.forEach {
            if (!it.name.startsWith("checker-qual-android")) {
                source += it.sourceSets.main.allJava
            }
        }

        classpath = configurations.allProjects

        destinationDir.deleteDir()
        options.memberLevel = memberLevel
        options.addBooleanOption('Xdoclint:all', true)
        options.addStringOption('Xmaxwarns', '99999')

        // options.addStringOption('skip', 'ClassNotToCheck|OtherClass')
    }
}

createJavadocTask('javadocDoclintAll', 'Runs javadoc with -Xdoclint:all option.', JavadocMemberLevel.PRIVATE)

task manual(group: 'Documentation') {
    description 'Build the manual'
    doLast {
        exec {
            commandLine "make", "-C", "docs/manual", "all"
        }
    }
}

// No group so it does not show up in the output of `gradlew tasks`
task downloadJtreg(type: Download) {
    description "Downloads and unpacks jtreg."
    onlyIf { !(new File("${jtregHome}/lib/jtreg.jar").exists()) }
    // src 'https://ci.adoptopenjdk.net/view/Dependencies/job/jtreg/lastSuccessfulBuild/artifact/jtreg-4.2.0-tip.tar.gz'
    // If ci.adoptopenjdk.net is down, use this copy.
    src 'https://checkerframework.org/jtreg-4.2.0-tip.tar.gz'
    dest new File(buildDir, 'jtreg-4.2.0-tip.tar.gz')
    overwrite true
    retries 3
    doLast {
        copy {
            from tarTree(dest)
            into "${jtregHome}/.."
        }
        exec {
            commandLine('chmod',  '+x', "${jtregHome}/bin/jtdiff", "${jtregHome}/bin/jtreg")
        }
    }
}

// See alternate implementation getCodeFormatScriptsInGradle below.
// No group so it does not show up in the output of `gradlew tasks`
task getCodeFormatScripts() {
    description 'Obtain or update the run-google-java-format scripts'
    if (file(formatScriptsHome).exists()) {
        exec {
            workingDir formatScriptsHome
            executable 'git'
            args = ['pull', '-q']
            ignoreExitValue = true
        }
    } else {
        exec {
            workingDir "${formatScriptsHome}/../"
            executable 'git'
            args = ['clone', '-q', '--depth', '1', 'https://github.com/plume-lib/run-google-java-format.git', '.run-google-java-format']
        }
    }
}

// This implementation is preferable to the above because it does work in Gradle rather than in bash.
// However, it fails in the presence of worktrees: https://github.com/ajoberstar/grgit/issues/97 .
// No group so it does not show up in the output of `gradlew tasks`
task getCodeFormatScriptsInGradle {
  description "Obtain the run-google-java-format scripts"
  doLast {
    if (! new File(formatScriptsHome).exists()) {
      // There is no support for the --depth argument:
      // https://github.com/ajoberstar/grgit/issues/155   https://bugs.eclipse.org/bugs/show_bug.cgi?id=475615
      def rgjfGit = Grgit.clone(dir: formatScriptsHome, uri: 'https://github.com/plume-lib/run-google-java-format.git')
    } else {
      def rgjfGit = Grgit.open(dir: formatScriptsHome)
      rgjfGit.pull()
    }
  }
}

// No group so it does not show up in the output of `gradlew tasks`
task getPlumeScripts() {
    description 'Obtain or update plume-scripts'
    if (file(plumeScriptsHome).exists()) {
        exec {
            workingDir plumeScriptsHome
            executable 'git'
            args = ['pull', '-q']
            ignoreExitValue = true
        }
    } else {
        exec {
            workingDir "${plumeScriptsHome}/../"
            executable 'git'
            args = ['clone', '-q', '--depth', '1', 'https://github.com/plume-lib/plume-scripts.git', '.plume-scripts']
        }
    }
}

// No group so it does not show up in the output of `gradlew tasks`
task getHtmlTools() {
    description 'Obtain or update html-tools'
    if (file(htmlToolsHome).exists()) {
        exec {
            workingDir htmlToolsHome
            executable 'git'
            args = ['pull', '-q']
            ignoreExitValue = true
        }
    } else {
        exec {
            workingDir "${htmlToolsHome}/../"
            executable 'git'
            args = ['clone', '-q', '--depth', '1', 'https://github.com/plume-lib/html-tools.git', '.html-tools']
        }
    }
}

// No group so it does not show up in the output of `gradlew tasks`
task pythonIsInstalled(type: Exec) {
  description "Check that the python3 executable is installed."
  executable = "python3"
  args "--version"
}

task tags {
    group 'Emacs'
    description 'Create Emacs TAGS table'
    doLast {
        exec {
            commandLine "etags", "-i", "checker/TAGS", "-i", "checker-qual/TAGS", "-i", "checker-util/TAGS", "-i", "dataflow/TAGS", "-i", "framework/TAGS", "-i", "framework-test/TAGS", "-i", "javacutil/TAGS", "-i", "docs/manual/TAGS"
        }
        exec {
            commandLine "make", "-C", "docs/manual", "tags"
        }
    }
}

subprojects {
    configurations {
        errorprone
    }

    dependencies {
        // https://mvnrepository.com/artifact/com.google.errorprone/error_prone_core
        // If you update this:
        //  * Temporarily comment out "-Werror" elsewhere in this file
        //  * Repeatedly run `./gradlew clean compileJava` and fix all errors
        //  * Uncomment "-Werror"
        //  * Don't edit framework/build.gradle to use the same version number
        //    (it is updated when the annotated version of Guava is updated).
        errorprone group: 'com.google.errorprone', name: 'error_prone_core', version: '2.7.1'
    }

    task checkFormat(type: Exec, dependsOn: [getCodeFormatScripts, pythonIsInstalled], group: 'Format') {
        description 'Check whether the source code is properly formatted'
        // checker-qual-android project has no source, so skip
        onlyIf {!project.name.startsWith('checker-qual-android') }
        executable 'python3'

        doFirst {
            args += "${formatScriptsHome}/check-google-java-format.py"
            args += getJavaFilesToFormat(project.name)
        }
        ignoreExitValue = true
        doLast {
            if (execResult.exitValue != 0) {
                throw new RuntimeException('Found improper formatting, try running:  ./gradlew reformat"')
            }
        }
    }

    task reformat(type: Exec, dependsOn: [getCodeFormatScripts, pythonIsInstalled], group: 'Format') {
        description 'Format the Java source code'
        // checker-qual-android project has no source, so skip
        onlyIf {!project.name.startsWith('checker-qual-android') }
        executable 'python3'
        doFirst {
            args += "${formatScriptsHome}/run-google-java-format.py"
            args += getJavaFilesToFormat(project.name)
        }
    }

    shadowJar {
        // If you add an external dependency, then do the following:
        // 1. Before adding the dependency, run ./gradlew copyJarsToDist.
        // 2. Copy checker/dist/checker.jar elsewhere.
        // 3. Add the dependency, then run ./gradlew clean copyJarsToDist.
        // 4. Unzip both jars and compare the contents.
        // 5. Add relocate lines below for the packages.
        // 6. Do steps 3-5 until all new classes are in org/checkerframework/.

        // Relocate packages that might conflict with user's classpath.
        relocate 'org.apache', 'org.checkerframework.org.apache'
        relocate 'org.relaxng', 'org.checkerframework.org.relaxng'
        relocate 'org.plumelib', 'org.checkerframework.org.plumelib'
        relocate 'org.codehaus', 'org.checkerframework.org.codehaus'
        relocate 'org.objectweb.asm', 'org.checkerframework.org.objectweb.asm'
        relocate 'io.github.classgraph', 'org.checkerframework.io.github.classgraph'
        relocate 'nonapi.io.github.classgraph', 'org.checkerframework.nonapi.io.github.classgraph'
        // relocate 'sun', 'org.checkerframework.sun'
        relocate 'com.google', 'org.checkerframework.com.google'
        relocate 'plume', 'org.checkerframework.plume'
        exclude '**/module-info.class'

        doFirst {
            if (release) {
                // Only relocate JavaParser during a release:
                relocate 'com.github.javaparser', 'org.checkerframework.com.github.javaparser'
            }
        }
    }

    if (!project.name.startsWith('checker-qual-android')) {
        task tags(type: Exec) {
            description 'Create Emacs TAGS table'
            commandLine "bash", "-c", "find . \\( -name build \\) -prune -o -name '*.java' -print | sort-directory-order | xargs ctags -e -f TAGS"
        }
    }

    java {
        withJavadocJar()
        withSourcesJar()
    }

    // Things in this block reference definitions in the subproject that do not exist,
    // until the project is evaluated.
    afterEvaluate {
        // Adds manifest to all Jar files
        tasks.withType(Jar) {
            includeEmptyDirs = false
            if (archiveFileName.get().startsWith("checker-qual") || archiveFileName.get().startsWith("checker-util")) {
                metaInf {
                    from './LICENSE.txt'
                }
            } else {
                metaInf {
                    from "${rootDir}/LICENSE.txt"
                }
            }
            manifest {
                attributes("Implementation-Version": "${project.version}")
                attributes("Implementation-URL": "https://checkerframework.org")
                if (! archiveFileName.get().endsWith("source.jar")) {
                    attributes('Automatic-Module-Name': "org.checkerframework." + project.name.replaceAll('-', '.'))
                }
                if (archiveFileName.get().startsWith("checker-qual") || archiveFileName.get().startsWith("checker-util")) {
                    attributes("Bundle-License": "MIT")
                } else {
                    attributes("Bundle-License": "(GPL-2.0-only WITH Classpath-exception-2.0)")
                }
            }
        }

        // Add tasks to run various checkers on all the main source sets.
        // These pass and are run by typecheckTests.
        createCheckTypeTask(project.name, 'Formatter',
            'org.checkerframework.checker.formatter.FormatterChecker')
        createCheckTypeTask(project.name, 'Interning',
            'org.checkerframework.checker.interning.InterningChecker',
            ['-Astubs=javax-lang-model-element-name.astub'])
        createCheckTypeTask(project.name, 'NullnessOnlyAnnotatedFor',
            'org.checkerframework.checker.nullness.NullnessChecker',
            ['-AskipUses=com.sun.*', '-AuseConservativeDefaultsForUncheckedCode=source'])
        createCheckTypeTask(project.name, 'Purity',
            'org.checkerframework.framework.util.PurityChecker')
        createCheckTypeTask(project.name, 'Signature',
            'org.checkerframework.checker.signature.SignatureChecker')
        // These pass on some subprojects, which the `typecheck` task runs.
        // TODO: Incrementally add @AnnotatedFor on more classes.
        createCheckTypeTask(project.name, 'Nullness',
            'org.checkerframework.checker.nullness.NullnessChecker',
            ['-AskipUses=com.sun.*'])


        // Add jtregTests to framework and checker modules
        if (project.name.is('framework') || project.name.is('checker')) {
            tasks.create(name: 'jtregTests', dependsOn: ':downloadJtreg', group: 'Verification') {
                description 'Run the jtreg tests.'
                dependsOn('compileJava')
                dependsOn('compileTestJava')
                dependsOn('shadowJar')

                String jtregOutput = "${buildDir}/jtreg"
                String name = 'all'
                String tests = '.'
                doLast {
                    exec {
                        executable "${jtregHome}/bin/jtreg"
                        args = [
                                "-dir:${projectDir}/jtreg",
                                "-workDir:${jtregOutput}/${name}/work",
                                "-reportDir:${jtregOutput}/${name}/report",
                                "-verbose:error,fail",
                                // Don't add debugging information
                                //  "-javacoptions:-g",
                                "-keywords:!ignore",
                                "-samevm",
                                "-javacoptions:-classpath ${tasks.shadowJar.archiveFile.get()}:${sourceSets.test.output.asPath}",
                                // Required for checker/jtreg/nullness/PersistUtil.java and other tests
                                "-vmoptions:-classpath ${tasks.shadowJar.archiveFile.get()}:${sourceSets.test.output.asPath}",
                        ]
                        if (isJava8) {
                            // Use Error Prone javac and source/target 8
                            args += [
                                "-vmoptions:-Xbootclasspath/p:${configurations.javacJar.asPath}",
                                "-javacoptions:-Xbootclasspath/p:${configurations.javacJar.asPath}",
                                "-javacoptions:-source 8",
                                "-javacoptions:-target 8"
                                ]
                        } else {
                            args += [
                                    // checker/jtreg/nullness/defaultsPersist/ReferenceInfoUtil.java
                                    // uses the jdk.jdeps module.
                                    "-javacoptions:--add-modules jdk.jdeps",
                                    "-javacoptions:--add-exports=jdk.jdeps/com.sun.tools.classfile=ALL-UNNAMED",
                                    "-vmoptions:--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
                            ]
                        }
                        if (project.name.is('framework')) {
                            // Do not check for the annotated JDK
                            args += [
                                    "-javacoptions:-ApermitMissingJdk"
                            ]
                        } else if (project.name.is('checker')) {
                            args += [
                                    "-javacoptions:-classpath ${sourceSets.testannotations.output.asPath}",
                            ]
                        }

                        // Location of jtreg tests
                        args += "${tests}"
                    }
                }
            }
        }

        // Create a task for each JUnit test class whose name is the same as the JUnit class name.
        sourceSets.test.allJava.filter { it.path.contains('test/junit') }.forEach { file ->
            String junitClassName = file.name.replaceAll(".java", "")
            tasks.create(name: "${junitClassName}", type: Test) {
                description "Run ${junitClassName} tests."
                include "**/${name}.class"
            }
        }

        // Configure JUnit tests
        tasks.withType(Test) {
            if (isJava8) {
                jvmArgs "-Xbootclasspath/p:${configurations.javacJar.asPath}".toString()
            } else {
                jvmArgs += [
                        "--illegal-access=warn",
                        "--add-opens", "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
                ]
            }

            maxParallelForks = Integer.MAX_VALUE

            if (project.name.is('checker')) {
                dependsOn('copyJarsToDist')
            }

            if (project.hasProperty('emit.test.debug')) {
                systemProperties += ["emit.test.debug": 'true']
            }

            testLogging {
                showStandardStreams = true
                // Always run the tests
                outputs.upToDateWhen { false }

                // Show the found unexpected diagnostics and expected diagnostics not found.
                exceptionFormat "full"
                events "failed"
            }

            // After each test, print a summary.
            afterSuite { desc, result ->
                if (desc.getClassName() != null) {
                    long mils = result.getEndTime() - result.getStartTime()
                    double seconds = mils / 1000.0

                    println "Testsuite: ${desc.getClassName()}\n" +
                            "Tests run: ${result.testCount}, " +
                            "Failures: ${result.failedTestCount}, " +
                            "Skipped: ${result.skippedTestCount}, " +
                            "Time elapsed: ${seconds} sec\n"
                }

            }
        }

        // Create a nonJunitTests task per project
        tasks.create(name: 'nonJunitTests', group: 'Verification') {
            description 'Run all Checker Framework tests except for the Junit tests and inference tests.'
            if (project.name.is('framework') || project.name.is('checker')) {
                dependsOn('jtregTests')
            }
            if (project.name.is('framework')) {
                dependsOn('loaderTests')
            }

            if (project.name.is('checker')) {
                if (!isJava8) {
                    dependsOn('jtregJdk11Tests')
                }
                dependsOn('nullnessExtraTests', 'commandLineTests', 'tutorialTests')
            }

            if (project.name.is('dataflow')) {
                dependsOn('liveVariableTest')
                dependsOn('issue3447Test')
            }
        }

        // Create an inferenceTests task per project
        tasks.create(name: 'inferenceTests', group: 'Verification') {
            description 'Run inference tests.'
            if (project.name.is('checker')) {
                dependsOn('wholeProgramInferenceTests', 'wpiManyTests', 'wpiPlumeLibTests')
            }
        }

        // Create a typecheck task per project (dogfooding the Checker Framework on itself).
        // This isn't a test of the Checker Framework as the test and nonJunitTests tasks are.
        // Tasks such as 'checkInterning' are constructed by createCheckTypeTask.
        tasks.create(name: 'typecheck', group: 'Verification') {
            description 'Run the Checker Framework on itself'
            dependsOn('checkFormatter', 'checkInterning', 'checkPurity', 'checkSignature')
            if (project.name.is('framework') || project.name.is('checker')) {
                dependsOn('checkNullnessOnlyAnnotatedFor', 'checkCompilerMessages')
            } else {
                dependsOn('checkNullness')
            }
        }

        // Create an allTests task per project.
        // allTests = test + nonJunitTests + inferenceTests + typecheck
        tasks.create(name: 'allTests', group: 'Verification') {
            description 'Run all Checker Framework tests'
            // The 'test' target is just the JUnit tests.
            dependsOn('test', 'nonJunitTests', 'inferenceTests', 'typecheck')
        }

        task javadocPrivate(dependsOn: javadoc) {
            doFirst {
                javadocMemberLevel = JavadocMemberLevel.PRIVATE
            }
            doLast {
                javadocMemberLevel = JavadocMemberLevel.PROTECTED
            }
        }
    }
}

assemble.dependsOn(':checker:copyJarsToDist')

task checkBasicStyle(group: 'Format') {
    description 'Check basic style guidelines, mostly whitespace.  Not related to Checkstyle tool.'
    String[] ignoreDirectories = ['.git',
                                  '.gradle',
                                  '.html-tools',
                                  '.idea',
                                  '.plume-scripts',
                                  '.run-google-java-format',
                                  'annotated',
                                  'api',
                                  'plume-bib',
                                  'bootstrap',
                                  'build',
                                  'jdk']

    String[] ignoreFilePatterns = [
            '*.aux',
            '*.bib',
            '*.class',
            '*.dvi',
            '*.expected',
            '*.gif',
            '*.jar',
            '*.jtr',
            '*.log',
            '*.out',
            '*.patch',
            '*.pdf',
            '*.png',
            '*.sty',
            '*.toc',
            '*.xcf',
            '*~',
            '#*#',
            'CFLogo.ai',
            'logfile.log.rec.index',
            'manual.html',
            'manual.html-e',
            'junit.*.properties',
            'securerandom.*',
            'checker/dist/META-INF/maven/org.apache.bcel/bcel/pom.xml',
            'checker/dist/META-INF/maven/org.apache.commons/commons-text/pom.xml',
            'framework/src/main/resources/git.properties']
    doLast {
        FileTree tree = fileTree(dir: projectDir)
        for (String dir : ignoreDirectories) {
            tree.exclude "**/${dir}/**"
        }
        for (String file : ignoreFilePatterns) {
            tree.exclude "**/${file}"
        }
        boolean failed = false
        tree.visit {
            if (!it.file.isDirectory()) {
                boolean blankLineAtEnd = false
                String fileName = it.file.getName()
                boolean checkTabs = !fileName.equals("Makefile")
                it.file.eachLine { line ->
                    if (line.endsWith(' ')) {
                        println("Trailing whitespace: ${it.file.absolutePath}")
                        failed = true
                    }
                    if (checkTabs && line.contains('\t')) {
                        println("Contains tab (use spaces): ${it.file.absolutePath}")
                        failed = true
                        checkTabs = false
                    }
                    if (!line.startsWith('\\') &&
                            (line.matches('^.* (else|finally|try)\\{}.*$')
                                    || line.matches('^.*}(catch|else|finally) .*$')
                                    || line.matches('^.* (catch|for|if|while)\\('))) {
                        // This runs on non-java files, too.
                        println("Missing space: ${it.file.absolutePath}")
                        failed = true
                    }
                    if (line.isEmpty()) {
                        blankLineAtEnd = true;
                    } else {
                        blankLineAtEnd = false;
                    }
                }

                if (blankLineAtEnd) {
                    println("Blank line at end of file: ${it.file.absolutePath}")
                    failed = true
                }

                RandomAccessFile file
                try {
                    file = new RandomAccessFile(it.file, 'r')
                    int end = file.length() - 1;
                    if (end > 0) {
                        file.seek(end)
                        byte last = file.readByte()
                        if (last != '\n') {
                            println("Missing newline at end of file: ${it.file.absolutePath}")
                            failed = true
                        }
                    }
                } finally {
                    if (file != null) {
                        file.close()
                    }
                }
            }
        }
        if (failed) {
            throw new GradleException("Files do not meet basic style guidelines.")
        }
    }
}
assemble.mustRunAfter(clean)
task buildAll(group: 'Build') {
    description 'Build all jar files, including source and javadoc jars'
    dependsOn(allJavadoc)
    subprojects { Project subproject ->
        dependsOn("${subproject.name}:assemble")
        dependsOn("${subproject.name}:javadocJar")
        dependsOn("${subproject.name}:sourcesJar")
    }
    dependsOn('framework:allJavadocJar', 'framework:allSourcesJar', 'checker:allJavadocJar', 'checker:allSourcesJar')
}

task releaseBuild(group: 'Build') {
    description 'Build everything required for a release'
    dependsOn(clean)
    doFirst {
        release = true
    }
    // Use finalizedBy rather than dependsOn so that release is set to true before any of the tasks are run.
    finalizedBy(buildAll)
}

// No group so it does not show up in the output of `gradlew tasks`
task releaseAndTest {
    description 'Build everything required for a release and run allTests'
    dependsOn(releaseBuild)
    subprojects { Project subproject ->
        dependsOn("${subproject.name}:allTests")
    }
}

// Don't create an empty checker-framework-VERSION.jar
jar.onlyIf {false}

/**
 * Adds the shared pom information to the given publication.
 * @param publication MavenPublication
 */
final sharedPublicationConfiguration(publication) {
    publication.pom {
        url = 'https://checkerframework.org'
        developers {
            // These are the lead developers/maintainers, not all the developers or contributors.
            developer {
                id = 'mernst'
                name = 'Michael Ernst'
                email = 'mernst@cs.washington.edu'
                url = 'https://homes.cs.washington.edu/~mernst/'
                organization = 'University of Washington'
                organizationUrl = 'https://www.cs.washington.edu/'
            }
            developer {
                id = 'smillst'
                name = 'Suzanne Millstein'
                email = 'smillst@cs.washington.edu'
                organization = 'University of Washington'
                organizationUrl = 'https://www.cs.washington.edu/'
            }
        }

        scm {
            url = 'https://github.com/typetools/checker-framework.git'
            connection = 'scm:git:git://github.com/typetools/checker-framework.git'
            developerConnection = 'scm:git:ssh://git@github.com/typetools/checker-framework.git'
        }
    }
}