apply plugin: 'org.jetbrains.kotlin.jvm'
apply plugin: 'net.corda.plugins.cordapp'

def javaHome = System.getProperty('java.home')
def shrinkJar = file("$buildDir/libs/${project.name}-${project.version}-tiny.jar")


import net.corda.plugins.SignJar
import proguard.gradle.ProGuardTask

import java.security.MessageDigest
import java.security.NoSuchAlgorithmException

static String sha256(File jarFile) throws FileNotFoundException, NoSuchAlgorithmException {
    InputStream input = new FileInputStream(jarFile)
    try {
        MessageDigest digest = MessageDigest.getInstance("SHA-256")
        byte[] buffer = new byte[8192]
        int bytesRead
        while ((bytesRead = input.read(buffer)) != -1) {
            digest.update(buffer, 0, bytesRead)
        }
        return digest.digest().encodeHex().toString()
    } finally {
        input.close()
    }
}

cordapp {
    targetPlatformVersion = corda_platform_version.toInteger()
    minimumPlatformVersion 1
    signing {
        // Cordapp is signed after the "shrink" task.
        enabled false
    }
    sealing {
        // Cannot seal JAR because other module also defines classes in the package net.corda.vega.analytics
        enabled false
    }
    contract {
        name "net/corda/vega/contracts"
        versionId 1
        vendor "R3"
        licence "Open Source (Apache 2)"
    }
}

configurations {
    shrinkArtifacts
}

dependencies {
    // The SIMM demo CorDapp depends upon Cash CorDapp features
    cordapp project(':finance:contracts')

    // Corda integration dependencies
    cordaProvided project(':core')


    // Cordapp dependencies
    // Specify your cordapp's dependencies below, including dependent cordapps
    implementation "com.opengamma.strata:strata-product:$strata_version"
    implementation "com.opengamma.strata:strata-market:$strata_version"
}

configurations.cordapp.canBeResolved = true
tasks.register('generateDependencies') {
    dependsOn project(':finance:contracts').tasks.jar
    def cordappDependencies = file("${sourceSets.main.output.resourcesDir}/META-INF/Cordapp-Dependencies")
    inputs.files(configurations.cordapp)
    outputs.files(cordappDependencies)
    doLast {
        cordappDependencies.newWriter().withWriter { writer ->
            configurations.cordapp.forEach { cordapp ->
                writer << sha256(cordapp) << System.lineSeparator()
            }
        }
    }
}
processResources.finalizedBy generateDependencies
jar.dependsOn generateDependencies

jar {
    // Test CorDapp filters out *-tests.jar. We only want the shrinked jar not this one.
    archiveClassifier = 'tests'
}

tasks.register('shrink', ProGuardTask) {
    injars jar
    outjars shrinkJar

    libraryjars "$javaHome/jmods"
    configurations.runtimeClasspath.forEach {
        libraryjars it.path, filter: '!META-INF/versions/**'
    }

    dontwarn 'afu.org.checkerframework.**'
    dontwarn 'co.paralleluniverse.**'
    dontwarn 'org.checkerframework.**'
    dontwarn 'org.joda.**'
    dontnote

    // We need to preserve our CorDapp's own directory structure so that Corda
    // can find the contract classes.
    keepdirectories 'net/corda/**'
    keepattributes '*'
    dontobfuscate
    dontoptimize
    verbose

    // These are our CorDapp classes, so don't change these.
    keep 'class net.corda.vega.** { *; }', includedescriptorclasses: true

    // Until CorDapps are isolated from each other, we need to ensure that the
    // versions of the classes that this CorDapp needs are still usable by other
    // CorDapps. Unfortunately, this means that we cannot shrink them as much as
    // we'd like to.
    keepclassmembers 'class com.opengamma.strata.** { *; }', includedescriptorclasses: true
    keepclassmembers 'class com.google.** { *; }', includedescriptorclasses: true
    keepclassmembers 'class org.joda.** { *; }', includedescriptorclasses: true
}

tasks.register('sign', SignJar) {
    inputJars shrink
}

jar.finalizedBy shrink
shrink.finalizedBy sign

artifacts {
    shrinkArtifacts shrinkJar
}