publish.gradle

// Apply the Maven Publish plugin once
apply plugin: 'maven-publish'

import org.gradle.api.file.RelativePath

// -----------------------------------------------------------------------------
// Common Variables & Config
// -----------------------------------------------------------------------------
ext.licenseFile = files("$rootDir/LICENSE.txt")
def athenaJsonFile = file("$projectDir/vendordeps/FRC6390-Athena-Core.json")
def defaultVersion = '2026.0.0'
def vendordepDescriptors = [
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-Core.json"),
        name      : "FRC6390 Athena Core",
        artifactId: 'athena-core',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-Core.json",
        uuid      : "1f3b1e19-0f9f-4f37-9f13-6a2b0b3764cb"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-CTRE.json"),
        name      : "FRC6390 Athena CTRE",
        artifactId: 'athena-ctre',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-CTRE.json",
        uuid      : "5f9b64e1-d3d7-4f5f-9b8f-3de54aa32ce3"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-REV.json"),
        name      : "FRC6390 Athena REV",
        artifactId: 'athena-rev',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-REV.json",
        uuid      : "b0e5a07b-6a34-4e2f-b9a8-4eac7e95c621"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-PhotonVision.json"),
        name      : "FRC6390 Athena PhotonVision",
        artifactId: 'athena-photonvision',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-PhotonVision.json",
        uuid      : "f0ab7d3a-6bfb-4c2b-8e3f-4a201215b688"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-Limelight.json"),
        name      : "FRC6390 Athena Limelight",
        artifactId: 'athena-limelight',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-Limelight.json",
        uuid      : "2bce0b98-1373-4c4c-8b53-04637a9550d5"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-HeliOS.json"),
        name      : "FRC6390 Athena HeliOS",
        artifactId: 'athena-helios',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-HeliOS.json",
        uuid      : "85556da2-a350-47f5-bb0b-db9680a0daea"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-Pathplanner.json"),
        name      : "FRC6390 Athena Pathplanner",
        artifactId: 'athena-pathplanner',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-Pathplanner.json",
        uuid      : "8e35b9f3-0f7d-4d52-90fc-7dbd06c7c2b0"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-Choreo.json"),
        name      : "FRC6390 Athena Choreo",
        artifactId: 'athena-choreo',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-Choreo.json",
        uuid      : "f8e0c33c-8f11-4d7d-9e3f-3de8792b3b49"
    ],
    [
        file      : file("$projectDir/vendordeps/FRC6390-Athena-Studica.json"),
        name      : "FRC6390 Athena Studica",
        artifactId: 'athena-studica',
        jsonUrl   : "https://raw.githubusercontent.com/FRC-6390/FRC-Athena/refs/heads/main/vendordeps/FRC6390-Athena-Studica.json",
        uuid      : "c4a4b4b9-737b-45be-9468-5d5df2c1d6ab"
    ],
]

def computeAutoVersion = {
    if (!athenaJsonFile.exists()) {
        return defaultVersion
    }

    try {
        def jsonContent = new groovy.json.JsonSlurper().parse(athenaJsonFile)
        def existingVersion = jsonContent?.version?.toString()
        def parts = existingVersion?.tokenize('.')

        if (parts?.size() == 3) {
            try {
                def patch = parts[2].toInteger() + 1
                return "${parts[0]}.${parts[1]}.${patch}"
            } catch (NumberFormatException ignored) {
                // Fall through to default
            }
        }
    } catch (Exception ignored) {
        // Fall through to default
    }

    return defaultVersion
}

def mavenUsername = project.findProperty('mavenUsername')
        ?: System.getenv('MAVEN_USERNAME')
        ?: System.getenv('USERNAME')
        ?: System.getenv('GITHUB_ACTOR')
def mavenPassword = project.findProperty('mavenPassword')
        ?: System.getenv('MAVEN_PASSWORD')
        ?: System.getenv('MAVEN_KEY')
        ?: System.getenv('GITHUB_TOKEN')

def providedVersion = project.hasProperty('version') ? project.property('version')?.toString() : null
def useProvidedVersion = providedVersion && providedVersion != org.gradle.api.Project.DEFAULT_VERSION && providedVersion.trim()

def pubVersion = useProvidedVersion ? providedVersion : computeAutoVersion()
def versionResolutionMessage = useProvidedVersion
        ? "Using provided Athena version ${pubVersion}"
        : "Auto-incremented Athena version to ${pubVersion}"

def computeFrcYear = {
    if (project.hasProperty('wpilibYear')) {
        return project.property('wpilibYear').toString()
    }

    def wpilibVersionCandidate = null
    if (project.hasProperty('wpilibVersion')) {
        wpilibVersionCandidate = project.property('wpilibVersion')?.toString()
    } else if (project.ext.has('wpilibVersion')) {
        wpilibVersionCandidate = project.ext.wpilibVersion?.toString()
    }

    if (wpilibVersionCandidate) {
        def matcher = (wpilibVersionCandidate =~ /(20\d{2})/)
        if (matcher.find()) {
            return matcher.group(1)
        }
    }

    return '2026'
}

def frcYear = project.hasProperty('frcYear') ? project.property('frcYear') : computeFrcYear()
def frcYearResolutionMessage = !project.hasProperty('frcYear')
        ? "Resolved FRC year to ${frcYear} from WPILib version"
        : null

// Group/Artifact used below and for updating JSON
def artifactGroupId = 'ca.frc6390.athena'

allprojects {
    group = artifactGroupId
    version = pubVersion
}

// Detect OS for WPILib folder
def osName = System.getProperty("os.name").toLowerCase()
def wpilibFolder
if (osName.contains("win")) {
    wpilibFolder = file("C:/Users/Public/wpilib/${frcYear}")
} else if (osName.contains("mac")) {
    wpilibFolder = file("/Users/Shared/wpilib/${frcYear}")
} else {
    wpilibFolder = file("/home/${System.getenv('USER')}/wpilib/${frcYear}")
}

// Key directories
def vendordepsFolder = file("$wpilibFolder/vendordeps")
def mavenFolder = file("$wpilibFolder/maven")
def outputsFolder = rootProject.file("${rootProject.buildDir}/outputs")
def versionFile = file("$outputsFolder/version.txt")
def localRepoDir = rootProject.file("${rootProject.buildDir}/repos/releases")

// Publish mode can be: 'local', 'online', 'all'
def publishMode = project.hasProperty('publishMode') ? project.property('publishMode') : 'local'
def buildConfigurationMessage = "Athena build configuration -> version: ${pubVersion}, frcYear: ${frcYear}, publishMode: ${publishMode}, wpilibFolder: ${wpilibFolder}"
if ((publishMode == 'online' || publishMode == 'all') && (!mavenUsername || !mavenPassword)) {
    throw new GradleException("Missing publish credentials. Provide -PmavenUsername/-PmavenPassword or MAVEN_USERNAME/MAVEN_PASSWORD (or GITHUB_ACTOR/GITHUB_TOKEN).")
}

gradle.buildFinished { _ ->
    logger.lifecycle(versionResolutionMessage)
    if (frcYearResolutionMessage != null) {
        logger.lifecycle(frcYearResolutionMessage)
    }
    logger.lifecycle(buildConfigurationMessage)
}

// -----------------------------------------------------------------------------
// Tasks: outputVersions, updateAthenaJson, copy tasks
// -----------------------------------------------------------------------------

task outputVersions() {
    description = 'Prints the version to a file (for use by downstream tasks)'
    group = 'Build'
    outputs.files(versionFile)
    inputs.property('pubVersion', pubVersion)

    doFirst {
        buildDir.mkdir()
        outputsFolder.mkdir()
        logger.lifecycle("Preparing Athena outputs in ${outputsFolder} (version ${pubVersion})")
    }

    doLast {
        logger.lifecycle("Recording Athena version ${pubVersion} to ${versionFile}")
        versionFile.write(pubVersion)
    }
}

def packagePattern = ~/^\s*package\s+([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*)\s*;/

def sourceJarRelativePath = { File sourceFile, RelativePath currentPath ->
    if (sourceFile == null || !sourceFile.name.endsWith('.java')) {
        return currentPath
    }

    String declaredPackage = null
    sourceFile.withReader('UTF-8') { reader ->
        String line
        while ((line = reader.readLine()) != null) {
            def matcher = line =~ packagePattern
            if (matcher.matches()) {
                declaredPackage = matcher.group(1)
                break
            }
            String trimmed = line.trim()
            if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('/*') && !trimmed.startsWith('*')) {
                break
            }
        }
    }

    if (declaredPackage == null || declaredPackage.isBlank()) {
        return currentPath
    }

    List<String> segments = new ArrayList<>(declaredPackage.tokenize('.'))
    segments.add(sourceFile.name)
    return new RelativePath(true, segments as String[])
}

// Ensure every subproject builds with Java 17 and publishes a sources jar
subprojects {
    apply plugin: 'maven-publish'
    plugins.withId('java') {
        java {
            sourceCompatibility = JavaVersion.VERSION_17
            targetCompatibility = JavaVersion.VERSION_17
        }

        tasks.register('subprojectSourcesJar', Jar) {
            archiveClassifier = 'sources'
            duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            from(sourceSets.main.allSource) {
                eachFile { details ->
                    details.relativePath = sourceJarRelativePath(details.file, details.relativePath)
                }
            }
            dependsOn classes
        }

        publishing {
            repositories {
                if (publishMode == 'local' || publishMode == 'all') {
                    maven {
                        name = "localRepo"
                        url = localRepoDir
                    }
                }
                if (publishMode == 'online' || publishMode == 'all') {
                    maven {
                        name = "FRC-Athena-GitHub"
                        url = "https://maven.pkg.github.com/FRC-6390/FRC-Athena"
                        credentials {
                            username = mavenUsername
                            password = mavenPassword
                        }
                    }
                }
            }

            publications {
                mavenJava(MavenPublication) {
                    from components.java
                    artifact tasks.named('subprojectSourcesJar')
                    groupId = artifactGroupId
                    artifactId = project.name
                    version = pubVersion
                }
            }
        }

        // Capture subproject outputs for artifact collection
        rootProject.copyAllOutputs.dependsOn tasks.named('jar'), tasks.named('subprojectSourcesJar')
        rootProject.copyAllOutputs.from(tasks.named('jar').map { it.archiveFile })
        rootProject.copyAllOutputs.from(tasks.named('subprojectSourcesJar').map { it.archiveFile })
    }
}

task updateAthenaJson {
    description = 'Updates vendordep JSON files with the correct version, frcYear, and javaDependencies'
    group = 'Publishing'
    inputs.files vendordepDescriptors.collect { it.file }
    inputs.property('pubVersion', pubVersion)
    inputs.property('frcYear', frcYear)
    outputs.dir outputsFolder

    doLast {
        vendordepDescriptors.each { desc ->
            if (!desc.file.exists()) {
                throw new GradleException("Missing vendordep template: ${desc.file}")
            }
            def jsonContent = new groovy.json.JsonSlurper().parse(desc.file)
            jsonContent.version = pubVersion
        jsonContent.frcYear = frcYear
        jsonContent.fileName = desc.file.name
        jsonContent.name = desc.name
        jsonContent.jsonUrl = desc.jsonUrl
        jsonContent.uuid = desc.uuid
        jsonContent.javaDependencies = [[
            groupId: artifactGroupId,
            artifactId: desc.artifactId,
            version: pubVersion
        ]]
            if (!jsonContent.mavenUrls || jsonContent.mavenUrls.isEmpty()) {
                jsonContent.mavenUrls = ["https://maven.frc6390.ca/FRC-6390/FRC-Athena"]
            }
            def updatedJson = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(jsonContent))
            desc.file.parentFile.mkdirs()
            desc.file.write(updatedJson)
        }
    }
}

task copyToWpilib(type: Copy) {
    description = 'Copies local Maven artifacts + updated JSON to WPILib folder'
    group = 'Publishing'
    dependsOn updateAthenaJson
    onlyIf { publishMode == 'local' || publishMode == 'all' }
    from localRepoDir
    into mavenFolder

    doFirst {
        wpilibFolder.mkdirs()
        mavenFolder.mkdirs()
        vendordepsFolder.mkdirs()
    }
}

copyToWpilib.dependsOn(subprojects.collect { it.tasks.named('publish') })

task copyJsonToVendordeps(type: Copy) {
    description = 'Copies the updated vendordep JSON files to the wpilib vendordeps folder'
    group = 'Publishing'
    dependsOn updateAthenaJson
    from vendordepDescriptors.collect { it.file }
    into vendordepsFolder
}

// -----------------------------------------------------------------------------
// Adding the extra build tasks from the second snippet
// -----------------------------------------------------------------------------

task libraryBuild() {
    description = 'Dummy library build task'
    group = 'Build'
}

// Simple copy-all-outputs pattern
task copyAllOutputs(type: Copy) {
    description = 'Copies all final outputs to a single folder'
    group = 'Build'
    destinationDir file("$buildDir/allOutputs")
    from versionFile
    dependsOn outputVersions, updateAthenaJson
}

tasks.register('buildAllModules') {
    description = 'Builds all subprojects so publication has outputs.'
    group = 'Build'
    dependsOn subprojects.collect { it.path + ":build" }
}

def athenaModuleNames = {
    return subprojects
            .collect { it.name }
            .findAll { it.startsWith('athena-') }
            .toSorted()
}

def runGitLines = { List<String> args ->
    def stdout = new ByteArrayOutputStream()
    def result = exec {
        commandLine(['git'] + args)
        standardOutput = stdout
        errorOutput = new ByteArrayOutputStream()
        ignoreExitValue = true
    }
    if (result.exitValue != 0) {
        return [] as List<String>
    }
    return stdout.toString('UTF-8')
            .readLines()
            .collect { it.trim().replace('\\', '/') }
            .findAll { !it.isEmpty() }
}

def resolveModuleDependencyMap = {
    def moduleNames = athenaModuleNames()
    def depMap = [:].withDefault { [] as Set<String> }
    moduleNames.each { moduleName ->
        depMap[moduleName] = [] as Set<String>
    }

    subprojects.each { subproj ->
        if (!moduleNames.contains(subproj.name)) return
        ['implementation', 'api', 'compileOnly', 'runtimeOnly'].each { cfgName ->
            def cfg = subproj.configurations.findByName(cfgName)
            if (cfg == null) return
            cfg.dependencies
                    .withType(org.gradle.api.artifacts.ProjectDependency)
                    .each { dep ->
                        if (moduleNames.contains(dep.dependencyProject.name)) {
                            depMap[subproj.name] << dep.dependencyProject.name
                        }
                    }
        }
    }
    return depMap.collectEntries { k, v -> [k, v.toList().toSorted()] }
}

def resolveChangedAthenaModules = {
    def moduleNames = athenaModuleNames()
    if (moduleNames.isEmpty()) {
        return [] as List<String>
    }

    def forceAll = (project.findProperty('buildAllModules')?.toString()?.toBoolean() ?: false)
    if (forceAll) {
        logger.lifecycle("buildAllModules=true; building all Athena modules.")
        return moduleNames
    }

    def diffBase = project.findProperty('changedSince')?.toString() ?: 'HEAD'
    def changedFiles = ([] as Set<String>)
    changedFiles.addAll(runGitLines(['diff', '--name-only', '--relative', diffBase]))
    changedFiles.addAll(runGitLines(['ls-files', '--others', '--exclude-standard']))

    if (changedFiles.isEmpty()) {
        logger.lifecycle("No changed files detected from git (base: ${diffBase}); skipping Athena module builds.")
        return [] as List<String>
    }

    def changedModules = [] as Set<String>
    def rootAffectsAll = [
            'build.gradle',
            'settings.gradle',
            'config.gradle',
            'publish.gradle',
            'gradle/libs.versions.toml',
            'gradle/wrapper/gradle-wrapper.properties',
            'gradlew',
            'gradlew.bat'
    ] as Set<String>

    def vendordepModuleByFile = vendordepDescriptors.collectEntries { [(it.file.name): it.artifactId] }
    vendordepModuleByFile['Studica-2026.0.0.json'] = 'athena-studica'

    changedFiles.each { path ->
        if (rootAffectsAll.contains(path) || path.startsWith('gradle/')) {
            changedModules.addAll(moduleNames)
            return
        }

        def moduleHit = moduleNames.find { module ->
            path == module || path.startsWith("${module}/")
        }
        if (moduleHit != null) {
            changedModules << moduleHit
            return
        }

        if (path.startsWith('vendordeps/')) {
            def vendordepName = path.substring('vendordeps/'.length())
            def mappedModule = vendordepModuleByFile[vendordepName]
            if (mappedModule != null) {
                changedModules << mappedModule
            } else {
                changedModules.addAll(moduleNames)
            }
        }
    }

    if (changedModules.isEmpty()) {
        logger.lifecycle("Changed files did not touch Athena modules; skipping Athena module builds.")
        return [] as List<String>
    }

    def depMap = resolveModuleDependencyMap()
    def affected = new LinkedHashSet<String>(changedModules)
    def added = true
    while (added) {
        added = false
        depMap.each { module, deps ->
            if (!affected.contains(module) && deps.any { affected.contains(it) }) {
                affected << module
                added = true
            }
        }
    }

    return affected.toList().toSorted()
}

tasks.register('buildChangedModules') {
    description = 'Builds only changed Athena modules and downstream dependents. Use -PbuildAllModules=true to force all.'
    group = 'Build'
    dependsOn {
        def affected = resolveChangedAthenaModules()
        if (affected.isEmpty()) {
            return []
        }
        logger.lifecycle("Affected Athena modules: ${affected.join(', ')}")
        return affected.collect { ":${it}:build" }
    }
}

// Utility extension to attach build artifacts to copyAllOutputs
ext.addTaskToCopyAllOutputs = { theTask ->
    copyAllOutputs.dependsOn theTask
    copyAllOutputs.inputs.file theTask.archiveFile
    copyAllOutputs.from theTask.archiveFile
}

// -----------------------------------------------------------------------------
// Jar tasks & artifacts
// -----------------------------------------------------------------------------

// Root competition artifacts are no longer published; subprojects provide all published jars.

// -----------------------------------------------------------------------------
// Wire up build dependencies
// -----------------------------------------------------------------------------

build.dependsOn outputVersions
build.dependsOn updateAthenaJson
build.dependsOn buildChangedModules
libraryBuild.dependsOn build
copyToWpilib.mustRunAfter publishToMavenLocal
copyJsonToVendordeps.mustRunAfter publishToMavenLocal

// -----------------------------------------------------------------------------
// Publishing Tasks
// -----------------------------------------------------------------------------

task publishLocal {
    group = 'Publishing'
    description = 'Publishes artifacts locally and copies them to the WPILib folder.'
    dependsOn publishToMavenLocal
}

// task publishOnline {
//     group = 'Publishing'
//     description = 'Publishes artifacts online to the GitHub Maven repository.'
//     dependsOn publish
// }

// Decide default publish behavior
if (publishMode == 'local') {
    publish.dependsOn publishLocal
} else if (publishMode == 'online') {
} else {
    publish.dependsOn publishLocal
}

tasks.matching { it.name == 'publish' }.configureEach {
    finalizedBy(copyJsonToVendordeps, copyToWpilib)
}

// -----------------------------------------------------------------------------
// Repositories & Publications
// -----------------------------------------------------------------------------

// Extra local 'releases' folder for debugging
def releasesRepoUrl = "${rootProject.buildDir}/repos/releases"

// An optional clean-up step. Remove if undesired.
task cleanReleaseRepo(type: Delete) {
    description = 'Cleans up the local releases repo before repopulating'
    delete releasesRepoUrl
}

// Clean once before publishing tasks so artifacts are not deleted between steps.
tasks.matching {
    it.name == 'publish' || it.name == 'publishLocal' || it.name == 'publishToMavenLocal'
}.configureEach {
    it.dependsOn cleanReleaseRepo
}

publishing {
    // Repositories
    repositories {
        // From the first snippet: local or online or both
        if (publishMode == 'local' || publishMode == 'all') {
            maven {
                name = "localRepo"
                url = localRepoDir
            }
        }

        if (publishMode == 'online' || publishMode == 'all') {
            maven {
                name = "FRC-Athena-GitHub"
                url = "https://maven.pkg.github.com/FRC-6390/FRC-Athena"
                credentials {
                    username = mavenUsername
                    password = mavenPassword
                }
            }
        }

        // // Additional local release repo (2nd snippet)
        // maven {
        //     name = "localReleasesRepo"
        //     url = releasesRepoUrl
        // }

        // // Another remote (if needed, can remove if duplicate)
        // maven {
        //     name = "FRC-Athena"
        //     url = "https://maven.pkg.github.com/FRC-6390/FRC-Athena"
        //     credentials {
        //         username = System.getenv("MAVEN_USERNAME")
        //         password = System.getenv("MAVEN_PASSWORD")
        //     }
        // }
    }
}

// -----------------------------------------------------------------------------
// Optional model publishing tasks removed; root competition artifacts are no
// longer published.
// -----------------------------------------------------------------------------