build.gradle

// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
//
// SPDX-License-Identifier: MPL-2.0

import javax.inject.Inject

plugins {
    id 'java'
    id 'maven-publish'
}

interface InjectedExecOps {
    @Inject
    ExecOperations getExecOperations()
}

group = 'org-power-grid-model'
version = '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

def pgmVersion = "1.13.109"

def pgmDir = layout.buildDirectory.dir("pgm").get()
def wheelDir = pgmDir.dir("download")
def headersDir = pgmDir.dir("headers")
def nativeLibDir = pgmDir.dir("lib")
def generatedJavaDir = pgmDir.dir("generated-src")

def architectures = [
    "x86_64_macosx": [
        url: "https://github.com/PowerGridModel/power-grid-model/releases/download/v$pgmVersion/power_grid_model-$pgmVersion-py3-none-macosx_13_0_x86_64.whl",
        wheelFile: wheelDir.file("power_grid_model_x86_64_macosx.whl"),
        nativeLibPathInWheel: "power_grid_model/_core/power_grid_model_c/lib/libpower_grid_model_c.dylib",
        nativeLibFile: nativeLibDir.file("power_grid_model_c_x86_64_macosx.dylib")
    ],
    "arm64_macosx": [
        url: "https://github.com/PowerGridModel/power-grid-model/releases/download/v$pgmVersion/power_grid_model-$pgmVersion-py3-none-macosx_13_0_arm64.whl",
        wheelFile: wheelDir.file("power_grid_model_arm64_macosx.whl"),
        nativeLibPathInWheel: "power_grid_model/_core/power_grid_model_c/lib/libpower_grid_model_c.dylib",
        nativeLibFile: nativeLibDir.file("power_grid_model_c_arm64_macosx.dylib")
    ],
    "x86_64_windows": [
        url: "https://github.com/PowerGridModel/power-grid-model/releases/download/v$pgmVersion/power_grid_model-$pgmVersion-py3-none-win_amd64.whl",
        wheelFile: wheelDir.file("power_grid_model_x86_64_windows.whl"),
        nativeLibPathInWheel: "power_grid_model/_core/power_grid_model_c/bin/power_grid_model_c.dll",
        nativeLibFile: nativeLibDir.file("power_grid_model_c_x86_64_windows.dll")
    ],
    "arm64_linux": [
        url: "https://github.com/PowerGridModel/power-grid-model/releases/download/v$pgmVersion/power_grid_model-$pgmVersion-py3-none-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl",
        wheelFile: wheelDir.file("power_grid_model_arm64_linux.whl"),
        nativeLibPathInWheel: "power_grid_model/_core/power_grid_model_c/lib64/libpower_grid_model_c.so",
        nativeLibFile: nativeLibDir.file("power_grid_model_c_arm64_linux.so")
    ],
    "x86_64_linux": [
        url: "https://github.com/PowerGridModel/power-grid-model/releases/download/v$pgmVersion/power_grid_model-$pgmVersion-py3-none-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl",
        wheelFile: wheelDir.file("power_grid_model_x86_64_linux.whl"),
        nativeLibPathInWheel: "power_grid_model/_core/power_grid_model_c/lib64/libpower_grid_model_c.so",
        nativeLibFile: nativeLibDir.file("power_grid_model_c_x86_64_linux.so")
    ]
]

tasks.register("extractPGMNativeLibsFromWheels") {
    doLast {
        nativeLibDir.file("version").asFile.write(pgmVersion)
    }
}

architectures.forEach { slug, architecture ->
    def downloadWheelTaskName = "downloadPGMWheel_$slug"
    def extractNativeLibTaskName = "extractPGMNativeLibFromWheel_$slug"

    tasks.named("extractPGMNativeLibsFromWheels") {
        dependsOn(tasks.named(extractNativeLibTaskName))
    }

    tasks.register(downloadWheelTaskName) {
        GString url = architecture.url
        RegularFile wheelFile = architecture.wheelFile

        outputs.file(wheelFile)

        doLast {
            def target = wheelFile.asFile
            target.parentFile.mkdirs()

            URI.create(url).toURL().withInputStream { input ->
                target.withOutputStream { output ->
                    output << input
                }
            }
        }
    }

    tasks.register(extractNativeLibTaskName, Copy) {
        dependsOn(tasks.named(downloadWheelTaskName))

        RegularFile wheelFile = architecture.wheelFile
        RegularFile nativeLibFile = architecture.nativeLibFile
        String nativeLibFilename = nativeLibFile.asFile.name
        String nativeLibPathInWheel = architecture.nativeLibPathInWheel

        // Ensure the target directory exists before extracting the library
        doFirst {
            nativeLibDir.asFile.mkdirs()
        }

        // Register the file as an output of the task to ensure Gradle tracks it correctly
        outputs.file(nativeLibFile)

        from(zipTree(wheelFile)) {
            include nativeLibPathInWheel

            eachFile { FileCopyDetails details ->
                if (details.path == null) {
                    return
                }
                println(details.path)
                details.path = nativeLibFilename
            }
        }

        includeEmptyDirs false
        into(nativeLibDir)
    }
}

tasks.register("extractPGMHeaderFiles", Copy) {
    dependsOn(tasks.named("extractPGMNativeLibFromWheel_x86_64_linux"))

    RegularFile wheelFile = architectures.x86_64_linux.wheelFile

    doFirst {
        headersDir.asFile.mkdirs()
    }

    def internalBaseDir = "power_grid_model/_core/power_grid_model_c/include"
    from(zipTree(wheelFile)) {
        include "$internalBaseDir/**/*.h"

        eachFile { FileCopyDetails details ->
            if (details.path == null) {
                return
            }

            details.path = details.path.replace("$internalBaseDir/", "")
        }
    }
    includeEmptyDirs false
    into headersDir
}

def jextractDir = layout.buildDirectory.dir("jextract").get()
def jextractArchive = jextractDir.file("jextract.tar.gz")

def osName = System.getProperty("os.name").toLowerCase()
def osArch = System.getProperty("os.arch").toLowerCase()

def jextractUrlPropertyKey = {
    if (osName.contains("linux")) {
        return osArch in ["aarch64", "arm64"]
                ? "jextract_linux_aarch64_url"
                : "jextract_linux_x64_url"
    }

    if (osName.contains("mac")) {
        return osArch in ["aarch64", "arm64"]
                ? "jextract_macos_aarch64_url"
                : "jextract_macos_x64_url"
    }

    if (osName.contains("windows")) {
        if (!(osArch in ["amd64", "x86_64"])) {
            throw new GradleException(
                    "Unsupported Windows architecture: $osArch"
            )
        }

        return "jextract_windows_x64_url"
    }

    throw new GradleException(
            "Unsupported platform: $osName / $osArch"
    )
}()

def jextractUrl = project.property(jextractUrlPropertyKey)

tasks.register("downloadJextract") {
    outputs.file(jextractArchive)
    doLast {
        def target = jextractArchive.asFile
        target.parentFile.mkdirs()
        URI.create(jextractUrl).toURL().withInputStream { input ->
            target.withOutputStream { output ->
                output << input
            }
        }
    }
}

tasks.register("extractJextract", Copy) {
    dependsOn(tasks.named("downloadJextract"))
    from tarTree(resources.gzip(jextractArchive.asFile))
    into jextractDir
}

tasks.register("generatePGMBindings") {
    // Use a local jextract installation by setting jextract_bin in gradle.properties,
    // otherwise jextract is downloaded and extracted automatically.
    def localJextractBin = project.findProperty("jextract_bin")
    if (!localJextractBin) {
        dependsOn(tasks.named('extractJextract'))
    }
    dependsOn(tasks.named('extractPGMNativeLibsFromWheels'))
    dependsOn(tasks.named('extractPGMHeaderFiles'))
    def execOps = project.objects.newInstance(InjectedExecOps)
    inputs.files(
            headersDir.file("power_grid_model_c.h"),
            headersDir.file("power_grid_model_c/dataset_definitions.h")
    )
    outputs.dir(generatedJavaDir)
    def jextractExecutables = fileTree(jextractDir) {
        include "**/bin/*"
    }
    doLast {
        def jextractBin
        if (localJextractBin) {
            jextractBin = file(localJextractBin)
        } else {
            def executableName = osName.contains("windows")
                    ? "jextract.exe"
                    : "jextract"
            def jextractBins = jextractExecutables.files.findAll() {
                it.name == executableName
            }
            if (jextractBins.size() != 1) {
                throw new GradleException(
                        "Expected exactly one Jextract executable, " +
                                "but found ${jextractBins.size()}: $jextractBins"
                )
            }
            jextractBin = jextractBins.first()
        }
        execOps.execOperations.exec {
            commandLine jextractBin,
                    "--output", generatedJavaDir,
                    "--target-package", "org.lfenergy.pgm",
                    "--header-class-name", "PowerGridModelC",
                    headersDir.file("power_grid_model_c.h").asFile,
                    headersDir.file(
                            "power_grid_model_c/dataset_definitions.h"
                    ).asFile
        }
    }
}

sourceSets {
    main {
        java {
            srcDir generatedJavaDir
        }
        resources {
            srcDir nativeLibDir
        }
    }
}

tasks.named('compileJava') {
    dependsOn(tasks.named('generatePGMBindings'))
}

tasks.named('processResources') {
    dependsOn(tasks.named('generatePGMBindings'))
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            artifactId = 'lib-power-grid-model'
        }
    }
}

dependencies {
    testImplementation platform('org.junit:junit-bom:6.0.0')
    testImplementation 'org.junit.jupiter:junit-jupiter'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

    testImplementation platform('org.mockito:mockito-bom:5.23.0')
    testRuntimeOnly 'org.mockito:mockito-core'
    testImplementation 'org.mockito:mockito-junit-jupiter'
}

test {
    useJUnitPlatform()
}