helper.gradle

buildscript {
    dependencies {
        classpath 'org.kohsuke:github-api:1.114'
    }

    repositories {
        gradlePluginPortal()
    }
}
def env = System.getenv()

//from https://lowcarbrob.medium.com/android-pro-tip-generating-your-apps-changelog-from-git-inside-build-gradle-19a07533eec4
String generateChangelog() {
    println "Assembeling Changelog ..."
    def lastTag = "git describe --tags --abbrev=0".execute().text.trim()
    def gitLogCmd = "git log $lastTag..HEAD --oneline --no-merges --pretty=format:\"%s\"".execute().text.trim()

    def features = ""
    def fixes = ""
    def changes = ""
    gitLogCmd.eachLine { gitLine ->
        def line = gitLine.substring(1, gitLine.length() - 1)
        if (line.trim().startsWith("[")) {
            def sline = line.split("]", 2)
            if (sline.length == 2) {
                def type = sline[0].trim().toLowerCase().substring(1)
                def comment = sline[1].trim()

                //filter issue links
                if (comment.contains("(")) {
                    def cline = comment.split("\\(", 2)
                    if (cline.length == 2 && cline[1].contains("#")) {
                        comment = cline[0].trim()
                    }
                }

                if (type == "fix" || type == "fixes" || type == "fixed") {
                    fixes += "- $comment \n"
                } else if (type == "feature" || type == "features") {
                    features += "- $comment \n"
                } else if (type == "change" || type == "changes" || type == "changed") {
                    changes += "- $comment \n"
                } else {
                    println "Unknown Type: $type ($line)"
                }
            }
        }

    }
    def changelog = ""
    if (!features.isEmpty()) {
        changelog += "#### Features\n"
        changelog += features.trim()
        changelog += "\n\n"
    }
    if (!changes.isEmpty()) {
        changelog += "#### Changes\n"
        changelog += changes.trim()
        changelog += "\n\n"
    }
    if (!fixes.isEmpty()) {
        changelog += "#### Fixes\n"
        changelog += fixes.trim()
        changelog += "\n\n"
    }

    println "Changelog since $lastTag:\n$changelog"
    return changelog
}

task changelog() {
    group = 'publishing'
    doLast {
        new File(projectDir, "CHANGES.md").text = generateChangelog()
    }
}

def requiredDependencies = evaluate(project.required_dependencies)
def optionalDependencies = evaluate(project.optional_dependencies)

modrinth {
    def changes = new File(projectDir, "CHANGES.md")
    if (changes.exists()) {
        changes = changes.getText('UTF-8')
    } else {
        changes = ""
    }
    def modrinth_token = new File(projectDir, "../MODRINTH_TOKEN")
    if (modrinth_token.exists()) {
        modrinth_token = modrinth_token.text
    } else {
        modrinth_token = ""
    }
    def slurper = new groovy.json.JsonSlurper()
    token = modrinth_token
    //modrinth_id
    projectId = project.archives_base_name
    versionNumber = project.mod_version
    versionType = project.release_channel
    uploadFile = remapJar
    gameVersions = slurper.parseText(project.modrinth_versions)
    loaders = ["fabric"]
    changelog = changes
    dependencies {
        requiredDependencies.each { dep ->
            print dep
            required.project dep
        }

        optionalDependencies.each { dep ->
            optional.project dep
        }
    }
    debugMode = false
}

curseforge {
    def slurper = new groovy.json.JsonSlurper()
    apiKey = new File(projectDir, "../CURSEFORGE_TOKEN")
    if (apiKey.exists()) {
        apiKey = apiKey.text
    } else {
        apiKey = ""
    }

    def changes = new File(projectDir, "CHANGES.md")
    if (changes.exists()) {
        changes = changes.getText('UTF-8')
    } else {
        changes = ""
    }

    project {
        id = project.curseforge_id
        changelogType = 'markdown'
        changelog = changes
        releaseType = project.release_channel
        def versions = slurper.parseText(project.modrinth_versions);
        def latestVersion = ''
        for (v in versions) {
            addGameVersion v
            latestVersion = "[$v]"
        }
        addGameVersion 'Fabric'
        addGameVersion 'Java 21'
        relations {
            requiredDependencies.each { dep ->
                requiredDependency dep
            }

            optionalDependencies.each { dep ->
                optionalDependency dep
            }
        }
        mainArtifact(remapJar) {
            displayName = "$project.archives_base_name-$project.version $latestVersion"
        }
        afterEvaluate {
            mainArtifact(remapJar.outputs)
        }
    }

    options {
        debug = false
        forgeGradleIntegration = false
    }
}


task nextVersion() {
    group = 'publishing'

    doLast {
        def slurper = new groovy.json.JsonSlurper();
        def inputFile = rootProject.file('modrinth.json')
        def gameVersions = java.net.URLEncoder.encode(project.modrinth_versions, "UTF-8")
        def json = slurper.parseText('[{ "version_number" : "1.0.-1" }]')
        try {
            new URL("https://api.modrinth.com/v2/project/${project.archives_base_name}/version?&game_versions=${gameVersions}").withInputStream { i -> inputFile.withOutputStream { it << i } }
            json = slurper.parseText(inputFile.text)
        } catch (FileNotFoundException) {
        }
        println(json)
        def version = json[0].version_number

        //increment patch version
        def indexedVersionList = version.split(/\./).toList().withIndex()
        indexedVersionList = indexedVersionList.collect { num, idx -> num.toInteger() }
        indexedVersionList[2] = indexedVersionList[2].value + 1
        def updatedVersion = indexedVersionList.join(".")

        println "\n\n"
        println "------------- CURRENT VERSION -------------"
        println "Last Published Version: " + version
        println "         Game Versions: " + json[0].game_versions
        println "                Status: " + json[0].status
        println "              Featured: " + json[0].featured
        println "            Downloaded: " + json[0].downloads
        println "\n"
        println "-------------- NEXT VERSION ---------------"
        println "Next Version: " + updatedVersion
        println "\n\n"


        def propertiesFile = new File("gradle.properties")
        def newContents = propertiesFile.text.replaceFirst("mod_version=\\d+.\\d+.\\d+", "mod_version=${updatedVersion}")
        propertiesFile.text = newContents

        def rootFabricFile = rootProject.file("src/main/resources/fabric.mod.json")
        def rootFabricFileJson = slurper.parseText(rootFabricFile.text)
        allprojects.each { proj ->
            if (proj.name == 'bclib-legacy' || proj.name == 'wunderlib') {
                println "Ignoring ${proj}"
                return
            }
            println "Updating Version in ${proj}"

            def fabricFile = proj.file("src/main/resources/fabric.mod.json")
            def fabricJson = slurper.parseText(fabricFile.text)
            fabricJson.version = updatedVersion
            fabricJson.depends.minecraft = slurper.parseText(modrinth_versions)
            fabricJson.depends.fabricloader = rootFabricFileJson.depends.fabricloader
            fabricJson.depends['fabric-api'] = rootFabricFileJson.depends['fabric-api']
            fabricJson.depends.java = rootFabricFileJson.depends.java

            fabricFile.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(fabricJson))
        }
    }
}

import org.kohsuke.github.GHReleaseBuilder
import org.kohsuke.github.GitHub

task github(dependsOn: [build, remapJar, sourcesJar, javadocJar]) {
    group = 'publishing'
    def slurper = new groovy.json.JsonSlurper()
    def apiKey = new File(projectDir, "../GITHUB_TOKEN")

    onlyIf {
        apiKey.exists()
    }

    doLast {
        apiKey = apiKey.text
        def changes = new File(projectDir, "CHANGES.md")
        if (changes.exists()) {
            changes = changes.getText('UTF-8')
        } else {
            changes = ""
        }

        def github = GitHub.connectUsingOAuth(apiKey as String)
        def repository = github.getRepository("quiqueck/" + archivesBaseName)

        def releaseBuilder = new GHReleaseBuilder(repository, version as String)
        releaseBuilder.name("${archivesBaseName}-${version}")
        releaseBuilder.body(changes)
        releaseBuilder.commitish("1.20")

        def ghRelease = releaseBuilder.create()
        ghRelease.uploadAsset(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar"), "application/java-archive");
        ghRelease.uploadAsset(file("${project.buildDir}/libs/${archivesBaseName}-${version}-sources.jar"), "application/java-archive");
        ghRelease.uploadAsset(file("${project.buildDir}/libs/${archivesBaseName}-${version}-javadoc.jar"), "application/java-archive");

        subprojects.each { sub ->
            ghRelease.uploadAsset(file("${sub.buildDir}/libs/${sub.archivesBaseName}-${version}.jar"), "application/java-archive");
            ghRelease.uploadAsset(file("${sub.buildDir}/libs/${sub.archivesBaseName}-${version}-sources.jar"), "application/java-archive");
        }
    }
}

subprojects {
    apply plugin: 'maven-publish'

    // Ensure the necessary tasks like remapJar exist in each subproject
    afterEvaluate {
        if (project.name == "wunderlib") return
        publishing {
            publications {
                mavenJava(MavenPublication) {
                    from components.java

                    // Customize the group, artifactId, and version for each subproject
                    groupId = group
                    artifactId = project.name
                    version = project.version

                    // Ensure remapJar is included
                    artifact(tasks.named('remapJar').get()) {
                        classifier "remapped-${project.name}"
                        builtBy tasks.named('remapJar').get()
                    }
                }
            }

            repositories {
                maven {
                    def slurper = new groovy.json.JsonSlurper()
                    def apiKey = slurper.parseText(new File(rootProject.projectDir, "../AMBER_TOKEN").text)
                    name = "Ambertation"
                    url = "https://maven.ambertation.de/releases/"
                    credentials {
                        username = apiKey.username
                        password = apiKey.token
                    }
                }
            }
        }
    }
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            def githubName = findProperty('github_base_name') ?: project.archives_base_name
            artifactId = project.archives_base_name
            // add all the jars that should be included when publishing to maven
            artifact(remapJar) {
                builtBy remapJar
            }
            artifact(sourcesJar) {
                builtBy remapSourcesJar
            }

            // Optional POM configuration
            pom {
                name = project.archives_base_name
                url = "https://github.com/quiqueck/${githubName}"

                licenses {
                    license {
                        name = 'The MIT License'
                        url = 'https://opensource.org/licenses/MIT'
                    }
                }

                scm {
                    connection = "scm:git:https://github.com/quiqueck/${githubName}.git"
                    developerConnection = "scm:git:https://github.com/quiqueck/${githubName}.git"
                    url = "https://github.com/quiqueck/${githubName}"
                }

                // Add subprojects as dependencies in the POM
                withXml {
                    def dependenciesNode = asNode().appendNode('dependencies')

                    subprojects.each { subproject ->
                        def dependencyNode = dependenciesNode.appendNode('dependency')


                        dependencyNode.appendNode('artifactId', subproject.name)
                        if (subproject.name == "wunderlib") {
                            dependencyNode.appendNode('groupId', "de.ambertation")
                            dependencyNode.appendNode('version', project.wunderlib_version)
                        } else {
                            dependencyNode.appendNode('groupId', group)
                            dependencyNode.appendNode('version', project.version)
                        }
                        println("Adding dependency: ${subproject.name} -> ${dependencyNode}")
                        dependencyNode.appendNode('scope', 'compile')
                    }
                }
            }
        }
    }
    repositories {
        maven {
            def slurper = new groovy.json.JsonSlurper();
            def apiKey = slurper.parseText(new File(projectDir, "../AMBER_TOKEN").text)
            println "\nPublishing ${project.archives_base_name} to Maven..."
            name = "Ambertation"
            url = "https://maven.ambertation.de/releases/"
            credentials {
                username = apiKey.username
                password = apiKey.token
            }
        }
    }
}