//plugins {
//    id 'org.javamodularity.moduleplugin'
//}
apply plugin: 'kotlin'
apply plugin: 'kotlin-jpa'
apply plugin: 'net.corda.plugins.quasar-utils'
apply plugin: 'net.corda.plugins.publish-utils'
apply plugin: 'net.corda.plugins.api-scanner'
apply plugin: 'com.jfrog.artifactory'

description 'Corda core'

evaluationDependsOn(':node:capsule')

//subprojects {
//    apply plugin: 'java'
//    apply plugin: "org.javamodularity.moduleplugin"
//    kotlinCompile {
//        moduleOptions {
//            addExports = [
//                    'java.base/sun.security.util': 'ALL-UNNAMED',
//                    'java.base/sun.security.x509': 'ALL-UNNAMED'
//            ]
//        }
//    }
//    compileJava {
//        moduleOptions {
////            addModules = []
////            addReads = [:]
////            addOpens = [:]
//            addExports = [
//                'java.base/sun.security.util': 'ALL-UNNAMED',
//                'java.base/sun.security.x509': 'ALL-UNNAMED'
////                'java.base/sun.security.util.BitArray': 'ALL-UNNAMED',
////                'java.base/sun.security.util.ObjectIdentifier': 'ALL-UNNAMED',
////                'java.base/sun.security.x509.AlgorithmId': 'ALL-UNNAMED',
////                'java.base/sun.security.x509.X509Key': 'ALL-UNNAMED'
//            ]
////            addExports = [:]
//        }
//    }
//    test {
//        moduleOptions {
//            addExports = [
//                    'java.base/sun.security.util': 'ALL-UNNAMED',
//                    'java.base/sun.security.x509': 'ALL-UNNAMED'
//            ]
//        }
//    }
//}

//allprojects {
//    apply plugin: 'java'
//    apply plugin: "org.javamodularity.moduleplugin"
//    compileJava {
//        moduleOptions {
//            addExports = [
//                    'java.base/sun.security.util': 'ALL-UNNAMED',
//                    'java.base/sun.security.x509': 'ALL-UNNAMED'
//            ]
//        }
//    }
//}

configurations {
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly

    smokeTestCompile.extendsFrom compile
    smokeTestRuntimeOnly.extendsFrom runtimeOnly
}

sourceSets {
    integrationTest {
        kotlin {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/kotlin')
        }
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/java')
        }
    }
    smokeTest {
        kotlin {
            // We must NOT have any Node code on the classpath, so do NOT
            // include the test or integrationTest dependencies here.
            compileClasspath += main.output
            runtimeClasspath += main.output
            srcDir file('src/smoke-test/kotlin')
        }
        java {
            compileClasspath += main.output
            runtimeClasspath += main.output
            srcDir file('src/smoke-test/java')
        }
    }
}

processSmokeTestResources {
    // Bring in the fully built corda.jar for use by NodeFactory in the smoke tests
    from(project(':node:capsule').tasks['buildCordaJAR']) {
        rename 'corda-(.*)', 'corda.jar'
    }
}

dependencies {

    testImplementation "org.junit.jupiter:junit-jupiter-api:${junit_jupiter_version}"
    testImplementation "junit:junit:$junit_version"
    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:${junit_vintage_version}"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_version}"
    testRuntimeOnly "org.junit.platform:junit-platform-launcher:${junit_platform_version}"

    testCompile "commons-fileupload:commons-fileupload:$fileupload_version"

    // Guava: Google test library (collections test suite)
    testCompile "com.google.guava:guava-testlib:$guava_version"

    // Bring in the MockNode infrastructure for writing protocol unit tests.
    testCompile project(":node-driver")

    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
    compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test:$kotlin_version"

    // Hamkrest, for fluent, composable matchers
    testCompile "com.natpryce:hamkrest:$hamkrest_version"

    // Thread safety annotations
    compile "com.google.code.findbugs:jsr305:$jsr305_version"

    // SLF4J: commons-logging bindings for a SLF4J back end
    compile "org.slf4j:jcl-over-slf4j:$slf4j_version"
    compile "org.slf4j:slf4j-api:$slf4j_version"

    // AssertJ: for fluent assertions for testing
    testCompile "org.assertj:assertj-core:${assertj_version}"

    // Guava: Google utilities library.
    testCompile "com.google.guava:guava:$guava_version"

    // For caches rather than guava
    compile "com.github.ben-manes.caffeine:caffeine:$caffeine_version"

    // Smoke tests do NOT have any Node code on the classpath!
    smokeTestImplementation "org.junit.jupiter:junit-jupiter-api:${junit_jupiter_version}"
    smokeTestImplementation "junit:junit:$junit_version"

    smokeTestRuntimeOnly "org.junit.vintage:junit-vintage-engine:${junit_vintage_version}"
    smokeTestRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_version}"
    smokeTestRuntimeOnly "org.junit.platform:junit-platform-launcher:${junit_platform_version}"

    smokeTestCompile project(':smoke-test-utils')
    smokeTestCompile "org.assertj:assertj-core:${assertj_version}"

    // RxJava: observable streams of events.
    compile "io.reactivex:rxjava:$rxjava_version"

    // Apache JEXL: An embeddable expression evaluation library.
    // This may be temporary until we experiment with other ways to do on-the-fly contract specialisation via an API.
    compile "org.apache.commons:commons-jexl3:3.0"
    compile 'commons-lang:commons-lang:2.6'

    // Java ed25519 implementation. See https://github.com/str4d/ed25519-java/
    compile "net.i2p.crypto:eddsa:$eddsa_version"

    // Bouncy castle support needed for X509 certificate manipulation
    compile "org.bouncycastle:bcprov-jdk15on:${bouncycastle_version}"
    compile "org.bouncycastle:bcpkix-jdk15on:${bouncycastle_version}"

    // JPA 2.2 annotations.
    compile "javax.persistence:javax.persistence-api:2.2"

    // required to use @Type annotation
    compile "org.hibernate:hibernate-core:$hibernate_version"

    compile group: "io.github.classgraph", name: "classgraph", version: class_graph_version

    // JDK 11 (https://stackoverflow.com/questions/52502189/java-11-package-javax-xml-bind-does-not-exist)
    compile group: 'javax.xml.bind', name: 'jaxb-api', version: '2.3.0'
}

//compileJava {
//    moduleOptions {
//        addExports = [
//                'java.base/sun.security.util': 'ALL-UNNAMED',
//                'java.base/sun.security.x509': 'ALL-UNNAMED'
//        ]
//    }
//}

// TODO Consider moving it to quasar-utils in the future (introduced with PR-1388)
task copyQuasarJar(type: Copy) {
    from configurations.quasar
    into "$project.rootProject.projectDir/lib"
    rename { filename -> "quasar.jar"}
}

jar {
    finalizedBy(copyQuasarJar)
    baseName 'corda-core'
}

configurations {
    testArtifacts.extendsFrom testRuntimeClasspath
}

tasks.withType(JavaCompile) {
    // Relaxes JPMS visibility constraints across module boundaries
    options.compilerArgs << '--add-exports' << 'java.base/sun.security.util=ALL-UNNAMED' << '--add-exports' << 'java.base/sun.security.x509=ALL-UNNAMED'
}

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {
    kotlinOptions {
        verbose = true
        allWarningsAsErrors = false
        // Kotlin Compiler does not yet support passing Modularity directives (eg. add-exports, add-reads, patch-module).
        // https://youtrack.jetbrains.com/issue/KT-20740
//        freeCompilerArgs = ['--add-export','java.base/sun.security.util=ALL-UNNAMED']
    }
}

tasks.withType(Test) {
    // fork a new test process for every test class
    forkEvery = 10
    
    ignoreFailures = true
    failFast = false
    jvmArgs '--add-exports=java.base/sun.security.util=ALL-UNNAMED'
}

task testJar(type: Jar) {
    classifier "tests"
    from sourceSets.test.output
}

task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
}

task smokeTestJar(type: Jar) {
    classifier 'smokeTests'
    from sourceSets.smokeTest.output
}

task smokeTest(type: Test) {
    dependsOn smokeTestJar
    testClassesDirs = sourceSets.smokeTest.output.classesDirs
    classpath = sourceSets.smokeTest.runtimeClasspath
}

artifacts {
    testArtifacts testJar
}

scanApi {
    excludeClasses = [
        // Kotlin should probably have declared this class as "synthetic".
        "net.corda.core.Utils\$toFuture\$1\$subscription\$1"
    ]
}

publish {
    name jar.baseName
}