publish.gradle

import java.security.MessageDigest

apply plugin: 'maven-publish'

publishing {
    repositories {
        maven {
            url "${System.getProperty('user.home')}/releases/maven/development"
        }
        maven {
            url "${System.getProperty('user.home')}/releases/maven/release"
        }
    }
}

def pubVersion = "${project.ext.version}-5"

def outputsFolder = file("$project.buildDir/outputs")

def baseArtifactId = 'opencv'
def artifactGroupId = 'org.photonvision.thirdparty.frc2024.opencv'
def zipBaseName = '_GROUP_org_photonvision_thirdparty_frc2024_opencv_ID_opencv-cpp_CLS'
def jniBaseName = "_GROUP_org_photonvision_thirdparty_frc2024_opencv_ID_opencv-jni_CLS"
def javaBaseName = "_GROUP_org_photonvision_thirdparty_frc2024_opencv_ID_opencv-java_CLS"

def versionFile = file("$outputsFolder/version.txt")

task outputVersions() {
    description = 'Prints the versions of this to a file for use by the downstream packaging project'
    group = 'Build'
    outputs.files(versionFile)

    doFirst {
        buildDir.mkdir()
        outputsFolder.mkdir()
    }

    doLast {
        versionFile.write pubVersion
    }
}

build.dependsOn outputVersions
copyAllOutputs.dependsOn outputVersions
copyAllOutputs.inputs.file versionFile
copyAllOutputs.from versionFile

task cppSourcesZip(type: Zip, dependsOn: make) {
    destinationDirectory = outputsFolder
    archiveBaseName = zipBaseName
    archiveClassifier = "sources"

    from(licenseFile) {
        into '/'
    }

    from('opencv/3rdparty') {
        into '/3rdparty'
        include '**/*.cpp', '**/*.h*'
    }

    from('opencv/modules') {
        into '/modules'
        include '**/*.cpp', '**/*.h*'
    }

    from(project.cmakeBuildDirectory.resolve('modules')) {
        into '/modules'
        include '**/*.cpp', '**/*.h*'
    }

    includeEmptyDirs = false
}

task cppHeadersZip(type: Zip, dependsOn: make) {
    destinationDirectory = outputsFolder
    archiveBaseName = zipBaseName
    archiveClassifier = "headers"

    from(licenseFile) {
        into '/'
    }

    from ('opencv/include') {
        into '/'
        exclude '**/CMakeLists.txt'
    }

    from (project.cmakeBuildDirectory.resolve('opencv2').toFile()) {
        into '/opencv2/'
    }

    from(rootPath.resolve('modules').toFile()) {
        include '*/include/**/*.hpp'
        include '*/include/**/*.h'
        exclude 'java/**'
        exclude 'python/**'
        eachFile { FileCopyDetails fcp ->
            fcp.relativePath = new RelativePath(!fcp.file.isDirectory(), fcp.relativePath.segments[2..-1] as String[])
        }
    }
    includeEmptyDirs = false
}
['', 'Debug' ].each{ buildType ->

    def staticBuildDir = buildType.contains('Debug') ? project.cmakeBuildDebugDirectory : project.cmakeBuildDirectory
    def sharedBuildDir = buildType.contains('Debug') ? project.cmakeBuildSharedDebugDirectory : project.cmakeBuildSharedDirectory

    def outputClassifier = project.ext.platformClassifier
    def outputClassifierStatic = project.ext.platformClassifier + 'static'
    if (buildType.contains('Debug')) {
        outputClassifier = outputClassifier + 'debug'
        outputClassifierStatic = outputClassifierStatic + 'debug'
    }

    def buildTypeFolder = buildType.contains('Debug') ? 'Debug' : 'Release'

    project.tasks.create('cppLibsZip' + buildType, Zip) {
        dependsOn tasks.named('makeShared' + buildType)
        destinationDirectory = outputsFolder
        archiveClassifier = outputClassifier
        archiveBaseName = zipBaseName
        duplicatesStrategy = 'exclude'

        manifest {
            attributes(
                    "Created-By": "WPILib Gradle Build Script",
                    "Implementation-Title": "OpenCV Native Libraries, ${project.ext.platformClassifier}",
                    "Implementation-Version": pubVersion,
                    "Implementation-Vendor": "Itseez",

                    "Bundle-Name": "${archiveBaseName.get()}",
                    "Bundle-Version": pubVersion,
                    "Bundle-License": "https://opensource.org/licenses/BSD-3-Clause",
                    "Bundle-Vendor": "WPILib")
        }

        from(licenseFile) {
            into '/'
        }

        if (!project.platform.startsWith("windows")) {
            if (buildType.contains('Debug') && project.platform.startsWith('linux')) {
                dependsOn 'stripLibsSharedDebug'
                from("$buildDir/stripSharedDebug") {
                    into project.platformPath + '/shared'
                }
            } else {
                def resolvedDir = sharedBuildDir.resolve("lib")
                if (project.platform.startsWith("osx")) {
                    resolvedDir = resolvedDir.resolve(buildTypeFolder)
                }
                from(resolvedDir.toFile()) {
                    into project.platformPath + '/shared'
                    include '*.so.*.*.*'
                    exclude 'cv2.so'
                    exclude '**/*dephelp*'
                    eachFile { f->
                        f.name = f.name.replace("${project.ext.version}", "${project.ext.soVersion}")
                    }
                }
                from(resolvedDir.toFile()) {
                    into project.platformPath + '/shared'
                    include "*.${project.ext.version}.dylib".toString()
                    eachFile { f->
                        f.name = f.name.replace("${project.ext.version}", "${project.ext.soVersion}")
                    }
                    exclude 'cv2.so'
                    exclude '**/*dephelp*'
                }
                from(resolvedDir.toFile()) {
                    into project.platformPath + '/shared'

                    include 'libopencv_java*.so'
                    include 'libopencv_java*.dylib'
                    exclude 'cv2.so'
                    exclude '**/*dephelp*'
                }
                from(sharedBuildDir.resolve("3rdparty").resolve("lib").toFile()) {
                    into project.platformPath + '/shared'
                    include '*.so'
                }
            }
        } else {
            from(sharedBuildDir.resolve("lib").resolve(buildTypeFolder).toFile()) {
                into project.platformPath + '/shared'
                include '*.lib'  // import library
                include '*.dll'
                include '*.pdb'
                exclude 'opencv_ts*'
            }
            from(sharedBuildDir.resolve("bin").resolve(buildTypeFolder).toFile()) {
                into project.platformPath + '/shared'
                include '*.lib'  // import library
                include '*.dll'
                include '*.pdb'
                exclude 'opencv_ts*'
            }
            from(sharedBuildDir.resolve("3rdparty").resolve("lib").toFile()) {
                into project.platformPath + '/shared'
                include '*.dll'
                include '*.pdb'
            }
        }
    }

    project.tasks.create('cppLibsZipStatic' + buildType, Zip) {
        dependsOn tasks.named('nativeLibLinks' + buildType)
        destinationDirectory = outputsFolder
        archiveClassifier = outputClassifierStatic
        archiveBaseName = zipBaseName
        duplicatesStrategy = 'exclude'

        manifest {
            attributes(
                    "Created-By": "WPILib Gradle Build Script",
                    "Implementation-Title": "OpenCV Native Libraries, ${project.ext.platformClassifier}",
                    "Implementation-Version": pubVersion,
                    "Implementation-Vendor": "Itseez",

                    "Bundle-Name": "${archiveBaseName.get()}",
                    "Bundle-Version": pubVersion,
                    "Bundle-License": "https://opensource.org/licenses/BSD-3-Clause",
                    "Bundle-Vendor": "WPILib")
        }

        from(licenseFile) {
            into '/'
        }

        if (!project.platform.startsWith("windows")) {
            def resolvedDir = staticBuildDir.resolve("lib")
            if (project.platform.startsWith("osx")) {
                resolvedDir = resolvedDir.resolve(buildTypeFolder)
            }
            from(resolvedDir.toFile()) {
                into project.platformPath + '/static'
                include 'libopencv*.a'
                exclude 'libopencv_*.a'
            }
        } else {
            from(staticBuildDir.resolve("lib").resolve(buildTypeFolder).toFile()) {
                into project.platformPath + '/static'
                include 'opencv*.lib'
                include '*.pdb'
                exclude 'opencv_*.lib'
            }
            from(sharedBuildDir.resolve("3rdparty").resolve("lib").toFile()) {
                into project.platformPath + '/static'
                include '*.pdb'
            }
        }
    }

    project.tasks.create('jniJar' + buildType, Jar) {
        dependsOn tasks.named('make' + buildType)
        dependsOn tasks.named('nativeLibLinks' + buildType)
        destinationDirectory = outputsFolder
        archiveClassifier = outputClassifier
        archiveBaseName = jniBaseName
        duplicatesStrategy = 'exclude'

        manifest {
            attributes(
                    "Created-By": "WPILib Gradle Build Script",
                    "Implementation-Title": "OpenCV JNI Library, ${project.ext.platformClassifier}",
                    "Implementation-Version": pubVersion,
                    "Implementation-Vendor": "Itseez",

                    "Bundle-Name": "${archiveBaseName.get()}",
                    "Bundle-Version": pubVersion,
                    "Bundle-License": "https://opensource.org/licenses/BSD-3-Clause",
                    "Bundle-Vendor": "WPILib")
        }

        from(licenseFile) {
            into '/'
        }

        def directory
        def jniFileName
        def jniFile

        if (project.platform.startsWith("linux")) {
            directory = staticBuildDir.resolve("lib").toFile()
            jniFileName = "libopencv_java${libVersion}.so"
            jniFile = new File(directory.absolutePath, "${jniFileName}")
        } else if (project.platform.startsWith("osx")) {
            directory = staticBuildDir.resolve("lib").resolve(buildTypeFolder).toFile()
            System.out.println(directory.absolutePath)
            jniFileName = "libopencv_java${libVersion}.dylib"
            jniFile = new File(directory.absolutePath, "${jniFileName}")
        } else {
            directory = staticBuildDir.resolve("lib").resolve(buildTypeFolder).toFile()
            jniFileName = "opencv_java${libVersion}.dll"
            jniFile = new File(directory.absolutePath, "${jniFileName}")
        }

        def hashFile = new File(directory.absolutePath, "opencv_java${libVersion}.hash")
        it.outputs.file(hashFile)
        it.from(hashFile) {
            into project.platformPath
        }
        it.doFirst {
            hashFile.text = MessageDigest.getInstance("MD5").digest(jniFile.bytes).encodeHex().toString()
        }
        it.from(jniFile) {
            into project.platformPath
        }
    }

}

task outputJar(type: Jar, dependsOn: make) {
    archiveBaseName = javaBaseName
    destinationDirectory = outputsFolder
    manifest {
        attributes(
                "Created-By": "WPILib Gradle Build Script",
                "Implementation-Title": "OpenCV",
                "Implementation-Version": pubVersion,
                "Implementation-Vendor": "Itseez",

                "Bundle-Name": project.name,
                "Bundle-Version": pubVersion,
                "Bundle-License": "https://opensource.org/licenses/BSD-3-Clause",
                "Bundle-Vendor": "WPILib")
    }

    from { zipTree(project.pathToOpenCVJar.toFile()) } {
        exclude 'META-INF/*'
        exclude 'META-INF'
        exclude '**/*.java'
    }
}

task sourcesJar(type: Jar, dependsOn: make) {
    archiveBaseName = javaBaseName
    destinationDirectory = outputsFolder
    archiveClassifier = 'sources'
    manifest {
        attributes(
                "Created-By": "WPILib Gradle Build Script",
                "Implementation-Title": "OpenCV Java Sources",
                "Implementation-Version": pubVersion,
                "Implementation-Vendor": "Itseez",

                "Bundle-Name": "${project.name}-sources",
                "Bundle-Version": pubVersion,
                "Bundle-License": "https://opensource.org/licenses/BSD-3-Clause",
                "Bundle-Vendor": "WPILib")
    }

    from(project.cmakeBuildDirectory.resolve("modules").resolve("java").resolve("jar").resolve("opencv").resolve("java").toFile()) {
        include '**/*.java'
    }
}


if (!project.hasProperty('skipRelease')) {
    build.dependsOn jniJar
    build.dependsOn cppLibsZip
    build.dependsOn cppLibsZipStatic
    addTaskToCopyAllOutputs(cppLibsZip)
    addTaskToCopyAllOutputs(jniJar)
    addTaskToCopyAllOutputs(cppLibsZipStatic)
}

if (!project.hasProperty('skipDebug')) {
    build.dependsOn cppLibsZipDebug
    build.dependsOn cppLibsZipStaticDebug
    build.dependsOn jniJarDebug

    addTaskToCopyAllOutputs(cppLibsZipDebug)
    addTaskToCopyAllOutputs(jniJarDebug)
    addTaskToCopyAllOutputs(cppLibsZipStaticDebug)
}

if (!project.hasProperty('skipSources')) {
    build.dependsOn cppHeadersZip
    build.dependsOn cppSourcesZip
    build.dependsOn outputJar
    build.dependsOn sourcesJar
    addTaskToCopyAllOutputs(cppSourcesZip)
    addTaskToCopyAllOutputs(cppHeadersZip)
    addTaskToCopyAllOutputs(outputJar)
    addTaskToCopyAllOutputs(sourcesJar)
}

if (!project.hasProperty('jenkinsBuild')) {
    artifacts {
        archives cppHeadersZip
        archives cppSourcesZip
        archives cppLibsZip
        archives jniJar
        archives cppLibsZipDebug
        archives cppLibsZipStatic
        archives cppLibsZipStaticDebug
        archives jniJarDebug
        archives outputJar
        archives sourcesJar
    }
}

model {
    publishing {
        publications {
            java(MavenPublication) {
                artifact outputJar
                artifact sourcesJar {
                }

                artifactId = "${baseArtifactId}-java"
                groupId artifactGroupId
                version pubVersion
            }
            jni(MavenPublication) {
                artifact jniJar
                artifact jniJarDebug

                artifactId = "${baseArtifactId}-jni"
                groupId artifactGroupId
                version pubVersion
            }
            cpp(MavenPublication) {
                artifact cppHeadersZip
                artifact cppSourcesZip
                artifact cppLibsZip
                artifact cppLibsZipDebug
                artifact cppLibsZipStatic
                artifact cppLibsZipStaticDebug

                artifactId = "${baseArtifactId}-cpp"
                groupId artifactGroupId
                version pubVersion
            }
        }
    }
}