build.gradle

import java.nio.file.Files;
import java.nio.file.StandardCopyOption;


buildscript {
    repositories {
        mavenCentral()
        google()
        maven {
            url = "https://plugins.gradle.org/m2/"
        }
        maven { url = uri("https://teavm.org/maven/repository") }
        maven { url = uri("https://maven.ngengine.org/riccardobl/teavm") }
    }
    dependencies {
        classpath libs.android.build.gradle
        classpath libs.spotbugs.gradle.plugin
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.20"
    }
}

plugins {
    id 'org.jetbrains.dokka' version '2.0.0'
    id 'com.diffplug.spotless' version '7.0.2' apply false
    id "io.github.gradle-nexus.publish-plugin"          version "2.0.0" 
}
apply from: file('version.gradle')

if(System.getenv("SONATYPE_USERNAME") || project.findProperty("sonatypeUsername")){
    nexusPublishing {
        repositories {
            sonatype {
                nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
                snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))

                username = System.getenv("SONATYPE_USERNAME") ?: project.findProperty("sonatypeUsername") ?: ""
                password = System.getenv("SONATYPE_PASSWORD") ?: project.findProperty("sonatypePassword") ?: ""
                packageGroup = "org.ngengine" 
            }
        }
    }
}


allprojects {
    group = 'org.ngengine'
    version = jmeFullVersion

    repositories {
        mavenLocal()
        mavenCentral()
        maven { 
           url = uri("https://central.sonatype.com/repository/maven-snapshots")
        }
        google()
        maven { url = uri("https://teavm.org/maven/repository") }
        maven { url = uri("https://maven.ngengine.org/riccardobl/teavm") }
    }
    tasks.withType(Jar) {
        duplicatesStrategy = 'include'
    }
}

def mergedJavadocSubprojects = [
        ":jme3-android",
        ":jme3-core",
        ":jme3-desktop",
        ":jme3-effects",
        ":jme3-ios",
        ":jme3-jbullet",
        ":jme3-jogg",
        ":jme3-lwjgl3",
        ":jme3-networking",
        ":jme3-plugins",
        ":jme3-terrain",
        ":nge-core",
        ":nge-app",
        ":nge-auth",

        ":nge-networking",
        ":nge-gui",
        ":nge-ads"

]

def ragDocProjects = [
        ":jme3-core",
        ":jme3-effects",
        ":jme3-networking",
        ":jme3-plugins",
        ":nge-core",
        ":nge-app",
        ":nge-auth",
        ":nge-networking",
        ":nge-gui",
        ":nge-ads"
]

// Set the license for IDEs that understand this
ext.license = file("$rootDir/source-file-header-template.txt")

apply plugin: 'base'
apply plugin: 'com.github.spotbugs'
apply plugin: 'org.jetbrains.dokka'
apply plugin: 'org.jetbrains.kotlin.jvm'

// This is applied to all sub projects
subprojects {

    if(!project.name.equals('jme3-android-examples')) {
        apply from: rootProject.file('common.gradle')
    } else {
        apply from: rootProject.file('common-android-app.gradle')
    }

    if (!project.name.endsWith("-native") && enableSpotBugs != "false" ) {
        apply plugin: 'com.github.spotbugs'

        // Currently we only warn about issues and try to fix them as we go, but those aren't mission critical.
        spotbugs {
            ignoreFailures = true
            toolVersion = libs.versions.spotbugs.get()
        }

        tasks.withType(com.github.spotbugs.snom.SpotBugsTask ) {
            reports {
                html.required = !project.hasProperty("xml-reports")
                xml.required = project.hasProperty("xml-reports")
            }
        }
    }
    if (ragDocProjects.contains(path)) {
        apply plugin: 'org.jetbrains.dokka'
        apply plugin: 'org.jetbrains.kotlin.jvm'

        dokkaGfm {
            moduleName.set(project.name)
            moduleVersion.set(project.version.toString())      
        }
    }

     if (name.startsWith("nge-")) {
        apply plugin: 'com.diffplug.spotless'

        spotless {
            enforceCheck = false
            java {
                importOrder()
                removeUnusedImports()
                cleanthat()
                prettier(['prettier': '2.8.8', 'prettier-plugin-java': '2.2.0'])
                    .config(['parser': 'java', 'tabWidth': 4, 'printWidth': 128])
                formatAnnotations()
            }
        }
    }

      // Prefer: <module>.LICENSE (e.g. nge-gui.LICENSE)
    // Fallback: <prefix>.LICENSE where prefix is before first '-' (e.g. nge.LICENSE)
    def moduleLicenseFile = file("${rootProject.rootDir}/${project.name}.LICENSE")
    def prefix = (project.name.contains('-') ? project.name.substring(0, project.name.indexOf('-')) : project.name)
    def prefixLicenseFile = file("${rootProject.rootDir}/${prefix}.LICENSE")
    File chosenLicenseFile = moduleLicenseFile.exists()
        ? moduleLicenseFile
        : (prefixLicenseFile.exists() ? prefixLicenseFile : null)
    if (chosenLicenseFile != null) {
        project.tasks.register('addLicenseHeaders') {
            description = 'Adds or updates license headers in Java files'
            group = 'formatting'

            def srcFiles = project.fileTree(dir: 'src', include: '**/java/**/*.java')

            def licenseText = chosenLicenseFile.text
            licenseText = licenseText.readLines().collect { " * " + it }.join("\n")
            licenseText = "/**\n" + licenseText + "\n */"

            doLast {
                def licenseHeader = licenseText

                // Only strip the legacy NGE header block.
                // Then only add the license if the file has no block comment containing "Copyright".
                def afterFirstComma = { String s ->
                    if (s == null) {
                        return null
                    }
                    def idx = s.indexOf(',')
                    if (idx < 0 || idx == s.length() - 1) {
                        return null
                    }
                    return s.substring(idx + 1).trim()
                }

                def licenseFirstLine = chosenLicenseFile.readLines('UTF-8')?.find { it != null } ?: ""
                def legacyHeaderMarker = afterFirstComma(licenseFirstLine) ?: licenseFirstLine.trim()

                def firstNonEmptyTextInBlock = { String block ->
                    def body = block
                            .replaceFirst(/(?s)\A\/\*{1,2}/, "")
                            .replaceFirst(/(?s)\*\/\s*\z/, "")

                    for (String line : body.readLines()) {
                        def t = line.trim()
                        if (t.startsWith("*")) {
                            t = t.substring(1).trim()
                        }
                        if (!t.isEmpty()) {
                            return t
                        }
                    }
                    return null
                }

                def shouldStripLegacyHeaderBlock = { String block ->
                    def firstLine = firstNonEmptyTextInBlock(block)
                    if (firstLine == null) {
                        return false
                    }
                    def markerInBlock = afterFirstComma(firstLine) ?: firstLine.trim()
                    return firstLine.trim().startsWith("Copyright") && markerInBlock == legacyHeaderMarker
                }

                def stripLeadingLegacyHeaderBlocks = { String s ->
                    s = s.replaceFirst(/^\uFEFF/, "")

                    while (true) {
                        def m = (s =~ /(?s)\A(\s*)(\/\*{1,2}.*?\*\/)(\s*)/)
                        if (!m.find()) {
                            break
                        }

                        def block = m.group(2)
                        if (shouldStripLegacyHeaderBlock(block)) {
                            s = s.substring(m.end())
                            continue
                        }

                        break
                    }

                    return s
                }

                def hasAnyCopyrightBlockComment = { String s ->
                    def m = (s =~ /(?s)\/\*{1,2}.*?\*\//)
                    while (m.find()) {
                        def block = m.group()
                        if (block != null && block.contains("Copyright")) {
                            return true
                        }
                    }
                    return false
                }

                srcFiles.each { f ->
                    def original = f.getText('UTF-8')
                    def stripped = stripLeadingLegacyHeaderBlocks(original)

                    // Rule 2: if any block comment contains "Copyright", do not add the license.
                    // Still persist the legacy-header removal if it changed the file.
                    def updated
                    if (hasAnyCopyrightBlockComment(stripped)) {
                        updated = stripped
                    } else {
                        def packageMatcher = stripped =~ /(?m)^package\s+[\w.]+;/
                        if (packageMatcher.find()) {
                            def position = packageMatcher.start()
                            updated =
                                    stripped.substring(0, position) +
                                    licenseHeader +
                                    "\n\n" +
                                    stripped.substring(position)
                        } else {
                            updated = licenseHeader + "\n\n" + stripped
                        }
                    }

                    if (updated != original) {
                        logger.info("Rewriting license header(s) in: ${f.path}")
                        f.write(updated, 'UTF-8')
                    } else {
                        logger.debug("License header already up-to-date in: ${f.path}")
                    }
                }
            }
        }
    } else {
        logger.info("No license file found for ${project.path} (tried ${project.name}.LICENSE and ${prefix}.LICENSE). Skipping addLicenseHeaders task.")
    }

}

tasks.register('run') {
    dependsOn ':jme3-examples:run'
    description = 'Run the jME3 examples'
}

defaultTasks 'run'


task mergedJavadoc(type: Javadoc, description: 'Creates Javadoc from all the projects.') {
    title = 'Nostr Game Engine'
    destinationDir = mkdir("dist/javadoc")

    options.encoding = 'UTF-8'
    

    // Allows Javadoc to be generated on Java 8 despite doclint errors.
    if (JavaVersion.current().isJava8Compatible()) {
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    options.overview = file("javadocfiles/javadoc-overview.html")
    options.stylesheetFile = file("javadocfiles/javadoc-style.css")

    source = mergedJavadocSubprojects.collect { project(it).sourceSets.main.allJava }
    classpath = files(mergedJavadocSubprojects.collect { project(it).sourceSets.main.compileClasspath })
}

def cleanMergedJavadoc = tasks.register('cleanMergedJavadoc', Delete) {
    delete file('dist/javadoc')
}

tasks.named('clean') {
    dependsOn cleanMergedJavadoc
}

ext {
    ndkCommandPath  = ""
    ndkExists       = false
}

apply from: 'gradle/jacoco.gradle'

task configureAndroidNDK {
    def ndkBuildFile = "ndk-build"
    // if windows, use ndk-build.cmd instead
    if (System.properties['os.name'].toLowerCase().contains('windows')) {
        ndkBuildFile = "ndk-build.cmd"
    }

    // ndkPath is defined in the root project gradle.properties file
    String ndkBuildPath = null;

    //Use the environment variable for the NDK location if defined
    if (System.env.ANDROID_NDK != null) {
        ndkBuildPath = System.env.ANDROID_NDK + File.separator + ndkBuildFile
    } else if (System.env.ANDROID_SDK != null) {
        ndkBuildPath = System.env.ANDROID_SDK + File.separator + "ndk" + File.separator + ndkBuildFile
    } else if (System.env.ANDROID_HOME != null) {
        def ndkBase = new File(System.env.ANDROID_HOME + File.separator + "Sdk" + File.separator + "ndk");
        if (ndkBase.exists()) {
            def ndkDirs = ndkBase.listFiles()?.findAll { it.isDirectory() } ?: []
            if (!ndkDirs.isEmpty()) {
                def latest = ndkDirs
                    .collect { [dir: it, ver: it.name.tokenize('._-').collect { token -> token.isInteger() ? token.toInteger() : token }] }
                    .max { it.ver }?.dir
                if (latest) {
                    ndkBuildPath = new File(latest, ndkBuildFile).absolutePath
                }
            }
        }
    }

    if (ndkBuildPath == null){
        ndkBuildPath = ndkPath + File.separator + ndkBuildFile
    }

    println "Using NDK path: " + ndkBuildPath
    if (new File(ndkBuildPath).exists()) {
        println "Found NDK build tool: " + ndkBuildPath
        ndkExists = true
        ndkCommandPath = ndkBuildPath
    }
}

gradle.rootProject.ext.set("usePrebuildNatives", buildNativeProjects!="true");

if (skipPrebuildLibraries != "true" && buildNativeProjects != "true") {
    File nativesSnapshotPropF = file('natives-snapshot.properties')

    if (nativesSnapshotPropF.exists()) {
        def readNativesConfig = {
            Properties nativesSnapshotProp = new Properties()
            nativesSnapshotPropF.withInputStream { nativesSnapshotProp.load(it) }

            String nativesSnapshot = nativesSnapshotProp.getProperty("natives.snapshot")
            if (!nativesSnapshot) {
                throw new GradleException("Missing 'natives.snapshot' in ${nativesSnapshotPropF}")
            }

            [
                snapshot: nativesSnapshot,
                url: PREBUILD_NATIVES_URL.replace('${natives.snapshot}', nativesSnapshot),
                zipFile: layout.buildDirectory.file("${nativesSnapshot}-natives.zip"),
                nativeDir: layout.buildDirectory.dir("native"),
            ]
        }

        def nativesZipFile = providers.provider { readNativesConfig().zipFile.get().asFile }
        def nativesPath = layout.buildDirectory.dir("native")

        def getNativesZipFile = tasks.register('getNativesZipFile') {
            outputs.file(nativesZipFile)
            doFirst {
                def nativesConfig = readNativesConfig()
                File target = nativesConfig.zipFile.get().asFile
                println("Use natives snapshot: ${nativesConfig.url}")
                println("Download natives from ${nativesConfig.url} to ${target}")
                target.getParentFile().mkdirs()
                ant.get(src: nativesConfig.url, dest: target)
            }
        }

        def extractPrebuiltNatives = tasks.register('extractPrebuiltNatives', Sync) {
            dependsOn(getNativesZipFile)
            into(nativesPath)
            from({
                zipTree(readNativesConfig().zipFile.get().asFile)
            }) {
                eachFile { details ->
                    def segments = details.relativePath.segments
                    if (segments.length <= 1) {
                        details.exclude()
                    } else {
                        details.relativePath = new RelativePath(details.isDirectory(), segments[1..-1] as String[])
                    }
                }
                includeEmptyDirs = false
            }
        }

        tasks.named('assemble') {
            dependsOn extractPrebuiltNatives
        }
    }
}



dokkaGfmMultiModule {
    outputDirectory.set(file("build/dokka"))
}

tasks.register('refreshCatalog') {
    group = 'build setup'
    description = 'Downloads the central NostrGameEngine Gradle version catalog.'

    def catalogUrl = providers.gradleProperty('centralCatalogUrl')
        .orElse('https://raw.githubusercontent.com/NostrGameEngine/libs.catalog/main/libs.versions.toml')
    def outputFile = layout.projectDirectory.file('gradle/libs.versions.toml')

    outputs.file(outputFile)

    doLast {
        def target = outputFile.asFile
        target.parentFile.mkdirs()
        target.text = new URI(catalogUrl.get()).toURL().getText('UTF-8')
        println "Refreshed ${target}"
    }
}