build.gradle.kts

import org.spongepowered.asm.gradle.plugins.MixinExtension
import com.matthewprenger.cursegradle.CurseExtension
import com.matthewprenger.cursegradle.CurseProject
import com.matthewprenger.cursegradle.CurseRelation
import com.modrinth.minotaur.ModrinthExtension
import com.modrinth.minotaur.TaskModrinthUpload
import net.minecraftforge.gradle.userdev.UserDevExtension
import org.apache.commons.lang3.StringUtils
import org.eclipse.jgit.api.Git
import org.eclipse.jgit.lib.Constants
import org.eclipse.jgit.lib.ObjectId
import org.eclipse.jgit.revwalk.RevCommit
import org.eclipse.jgit.revwalk.RevObject
import org.eclipse.jgit.revwalk.RevTag
import org.eclipse.jgit.revwalk.RevWalk
import java.util.*

buildscript {
    repositories {
        mavenCentral()
        maven {
            name = "jitpack"
            setUrl("https://jitpack.io")
        }
        maven {
            name = "forge"
            setUrl("https://maven.minecraftforge.net/")
        }
        maven {
            name = "sponge"
            setUrl("https://repo.spongepowered.org/repository/maven-public/")
        }
    }

    dependencies {
        //minecraft 'net.minecraftforge:forge:1.19.3-44.1.0'
        classpath("org.eclipse.jgit:org.eclipse.jgit:5.8.0.202006091008-r")
        classpath("org.apache.commons:commons-lang3:3.12.0")
        classpath("org.spongepowered:mixingradle:0.7.+")
    }
}

plugins {
    id("eclipse")
    id("maven-publish")
    id("net.minecraftforge.gradle") version "[6.0,6.2)"
    id("java")
    id("com.matthewprenger.cursegradle") version "1.1.0"
    id("com.modrinth.minotaur") version "2.+"
}
apply(plugin = "org.spongepowered.mixin")

val Project.mixin: MixinExtension
    get() = extensions.getByType()
mixin.run {
    add(sourceSets.main.get(), "flansmod.refmap.json")
    config("flansmod.mixins.json")
}

val config: Properties = file("gradle.properties").inputStream().let {
    val prop = Properties()
    prop.load(it)
    return@let prop
}

val git: Git = Git.open(projectDir)
val modBaseName = "flansmod"

// FML Versioning, different to Forge?
val fmlRange = config["fml.version.range"] as String

// Forge versioning
val forgeVersion = config["forge.version"] as String
val forgeVersionMax = config["forge.version.max"] as String
val forgeVersionRange = "[$forgeVersion, $forgeVersionMax)"

// Minecraft versioning
val mcVersion = config["minecraft.version"] as String
val mcVersionMax = config["minecraft.version.max"] as String
val mcVersionRange = "[$mcVersion, $mcVersionMax)"
val mcFullVersion = "$mcVersion-${config["forge.version"]}"

// JEI versioning
val jeiVersion = config["jei.version"] as String
val jeiVersionMax = config["jei.version.max"] as String
val jeiVersionRange = "[$jeiVersion, $jeiVersionMax)"

// Mod versioning
val majorVersion = config["flansmod.version.major"] as String
val minorVersion = config["flansmod.version.minor"] as String
val modVersionNoBuild = "$majorVersion.$minorVersion"
val modVersion = "$modVersionNoBuild.${getBuildNumber()}"
val modCurseForgeID = config["flansmod.curseforge"] as String
val modModrinthSlug = config["flansmod.modrinth-slug"] as String

val packModVersionMin = config["packs.flansmod.version.min"] as String
val packModVersionMax = config["packs.flansmod.version.max"] as String
val packModVersionRange = "[$packModVersionMin, $packModVersionMax)"

// Basic Parts versioning
val basicsVersionMajor = config["basics.version.major"] as String
val basicsVersionMinor = config["basics.version.minor"] as String
val basicsVersionNoBuild = "$basicsVersionMajor.$basicsVersionMinor";
val basicsVersion = "$basicsVersionNoBuild.${getBuildNumber()}"
val basicsCurseForgeID = config["basics.curseforge"] as String
val basicsModrinthSlug = config["basics.modrinth-slug"] as String

// Vender's Game versioning
val vendersVersionMajor = config["venders.version.major"] as String
val vendersVersionMinor = config["venders.version.minor"] as String
val vendersVersionNoBuild = "$vendersVersionMajor.$vendersVersionMinor";
val vendersVersion = "$vendersVersionNoBuild.${getBuildNumber()}"
val vendersCurseForgeID = config["venders.curseforge"] as String
val vendersModrinthSlug = config["venders.modrinth-slug"] as String

// Curse
val curseForgeReleaseType = config["curseforge.releasetype"] as String




// Mojang ships Java 17 to end users in 1.18+, so your mod should target Java 17.
java.toolchain.languageVersion.set(JavaLanguageVersion.of(17))


version = "$mcVersion-$modVersion"
group = "com.flansmod"
configure<BasePluginConvention> {
    archivesBaseName = "flansmod-all"
}

configure<UserDevExtension> {
    mappings("official",  "1.20.1")
}

repositories {
    maven {
        // location of the maven that hosts JEI files since January 2023
        name = "Jared's maven"
        setUrl("https://maven.blamejared.com/")
    }
}


dependencies {
    //"deobfCompile"("mezz.jei:jei_$mcVersion:$jeiVersion")
    "minecraft"("net.minecraftforge:forge:$mcFullVersion")
    annotationProcessor("org.spongepowered:mixin:0.8.5:processor")
    // compile against the JEI API but do not include it at runtime
    compileOnly(fg.deobf("mezz.jei:jei-${mcVersion}-common-api:${jeiVersion}"))
    compileOnly(fg.deobf("mezz.jei:jei-${mcVersion}-forge-api:${jeiVersion}"))
    // at runtime, use the full JEI jar for Forge
    runtimeOnly(fg.deobf("mezz.jei:jei-${mcVersion}-forge:${jeiVersion}"))
}

// processResources
val Project.minecraft: UserDevExtension
    get() = extensions.getByName<UserDevExtension>("minecraft")

minecraft.runs.create("client") {
    workingDirectory = "run"
    jvmArgs = listOf( "-XX:+AllowRedefinitionToAddDeleteMethods" )
    properties["forge.logging.markers"] = "REGISTRIES"
    properties["forge.logging.console.level"] = "debug"
    properties["forge.enabledGameTestNamespaces"] = "flansmod"
    mods.create("flansmod") {
        sources.add(sourceSets.main.get())
    }
    mods.create("flansbasicparts") {
        sources.add(sourceSets.main.get())
    }
    mods.create("flansvendersgame") {
        sources.add(sourceSets.main.get())
    }
}

minecraft.runs.create("server") {
    workingDirectory = "run"
    properties["forge.logging.markers"] = "REGISTRIES"
    properties["forge.logging.console.level"] = "debug"
    properties["forge.enabledGameTestNamespaces"] = "flansmod"
    mods.create("flansmod") {
        sources.add(sourceSets.main.get())
    }
    mods.create("flansbasicparts") {
        sources.add(sourceSets.main.get())
    }
    mods.create("flansvendersgame") {
        sources.add(sourceSets.main.get())
    }
}


tasks.withType<Jar> {
    // this will ensure that this task is redone when the versions change.
    inputs.property("version", project.version)

    archiveBaseName.set("flansmod-all")

    archiveVersion.set(mcVersion)

    // replace stuff in mcmod.info and mods.toml
    filesMatching(listOf("*/flansmod.toml", "*/flansvendersgame.toml", "*/flansbasicparts.toml"))
    {
        expand(
            mapOf(
                    "fmlrange" to fmlRange,
                    "flansmodversion" to modVersionNoBuild,
                    "flansvendersgameversion" to vendersVersion,
                    "flansbasicpartsversion" to basicsVersion,
                    "mcversionrange" to mcVersionRange,
                    "forgeversionrange" to forgeVersionRange,
                    "flansmodversionrange" to packModVersionRange,
                    "jeiversionrange" to jeiVersionRange,

        ))
    }
}

// workaround for userdev bug
tasks.create("copyResourceToClasses", Copy::class) {
    tasks.classes.get().dependsOn(this)
    dependsOn(tasks.processResources.get())
    onlyIf { gradle.taskGraph.hasTask(tasks.getByName("prepareRuns")) }
    into("$buildDir/classes/kotlin/main")
    from(tasks.processResources.get().destinationDir)
}

val jar: Jar by tasks
jar.apply {
    manifest {
        attributes(mapOf("FMLAT" to "flansmod_at.cfg",
                //"FMLCorePlugin" to "flansmod.common.asm.FlansModLoadingPlugin",
                "FMLCorePluginContainsFMLMod" to "true"))
    }
}

val reobfTask = jar.finalizedBy("reobfJar")

// ---------------------- BUILD AND REPACK TASKS ---------------------------
val sourceTask: Jar = tasks.create("source", Jar::class.java) {
    from(sourceSets["main"].allSource)
    archiveClassifier.set("sources")
}

val devTask: Jar = tasks.create("dev", Jar::class.java) {
    from(sourceSets["main"].output)
}







fun modTask(taskName: String, srcTask: Task, classfier: String): Jar {
    return tasks.create(taskName, Jar::class.java) {
        dependsOn(srcTask)
        from(zipTree(srcTask.outputs.files.singleFile))
        {
            include("**/assets/flansmod/")
            include("**/assets/flansphysics/")
            include("**/assets/forge/")
            include("**/assets/minecraft")
            include("**/com/flansmod/physics/")
            include("**/com/flansmod/common/")
            include("**/com/flansmod/client/")
            include("**/com/flansmod/util/")
            include("**/META-INF/flansmod.toml")
            include("**/flansmod.mcmeta")
            include("**/flansmod.png")

            // Special handling: Don't include dev tags, include (and rename) the partial tag files
            include("**/data/flansmod/")
            exclude("**/data/flansmod/tags/")
            include("**/data/**/tags/partial_tags/flansmod/**/*.json")

            // Special handling: Same for loot_modifiers
            include("**/data/forge/")
            exclude("**/data/forge/loot_modifiers/")
            include("**/data/forge/partial_loot_modifiers/flansmod/")
        }
        rename { name ->
            if (name == "flansmod.toml")
                "mods.toml"
            else if(name == "flansmod.mcmeta")
                "pack.mcmeta"
            else if(name.contains("/partial_tags/flansmod/"))
                name.replace("/partial_tags/flansmod/", "/tags/")
            else if(name.contains("/partial_loot_modifiers/flansmod/"))
                name.replace("/partial_loot_modifiers/flansmod/", "/loot_modifiers/")
            else name
        }
        includeEmptyDirs = false
        archiveClassifier.set(classfier)
        archiveVersion.set("$mcVersion-$modVersion")
        archiveBaseName.set("flansmod")
        destinationDirectory.set(file("$projectDir/build/output"))
        group = "flansmod build"
    }
}

fun repackTask(taskName: String, modID: String, modNamespace: String, srcTask: Task, classfier: String): Jar {
    return tasks.create(taskName, Jar::class.java) {
        dependsOn(srcTask)
        from(zipTree(srcTask.outputs.files.singleFile))
        {

            include("**/assets/$modID/")
            include("**/com/flansmod/packs/$modNamespace/")
            include("**/META-INF/$modID.toml")
            include("**/$modID.mcmeta")
            include("**/$modID.png")

            // We don't want our "compiled" tags, these contain every modded tag in our workspace and are for dev use
            include("**/data/$modID/")
            exclude("**/data/$modID/tags/")
            include("**/data/**/partial_tags/$modID/**/*_.json")

            // Same applies to loot modifiers, if we have any
            include("**/data/forge/partial_loot_modifiers/$modID/")
        }
        rename { name ->
            if (name == "$modID.toml")
                "mods.toml"
            else if (name == "$modID.mcmeta")
                "pack.mcmeta"
            else if(name.contains("/partial_tags/$modID/"))
                name.replace("/partial_tags/$modID/", "/tags/")
            else if(name.contains("/partial_loot_modifiers/$modID/"))
                name.replace("/partial_loot_modifiers/$modID/", "/loot_modifiers/")
            else name
        }
        includeEmptyDirs = false
        archiveClassifier.set(classfier)
        archiveVersion.set("$mcVersion-$modVersion")
        archiveBaseName.set(modID)
        destinationDirectory.set(file("$projectDir/build/output"))
        group = "flansmod build"
    }
}


val cleanTask: Delete = tasks.create("CleanExpandedFolder", Delete::class.java) {
    delete(
            fileTree("$projectDir/build/expanded"),
            fileTree("$projectDir/build/pack"))
    group = "flansmod internal"
}
fun expandJarTask(srcTask: Task, completeFolder: File): Copy {

    return tasks.create("Expand_${srcTask.name}", Copy::class.java) {
        dependsOn(cleanTask)
        dependsOn(srcTask)
        from(zipTree(srcTask.outputs.files.singleFile))
        {

        }
        includeEmptyDirs = false
        destinationDir = completeFolder
        group = "flansmod internal"
    }
}
fun gatherFilesForPackTask(modID: String, modNamespace: String, classifier:String, expandTask: Task, expandedDir: File, outputDir:File): Copy {
    return tasks.create("GatherFiles_${modID}_${classifier}", Copy::class.java) {
        dependsOn(expandTask)
        into("")
        {
            from(fileTree(expandedDir))
            {
                include("**/assets/$modID/")
                include("**/data/$modID/")
                include("**/com/flansmod/packs/$modNamespace/")
                include("**/$modID.mcmeta")
                include("**/$modID.png")
                include("**/META-INF/$modID.toml")

                exclude("**/data/$modID/tags/")
                exclude("**/data/$modID/loot_modifiers/")
                exclude("**/data/$modID/partial_data/")
            }
            rename { name ->
                if (name == "$modID.toml")
                    "mods.toml"
                else if (name == "$modID.mcmeta")
                    "pack.mcmeta"
                else name
            }
        }
        into("data")
        {
            from(fileTree(file("$expandedDir/data/$modID/partial_data/")))
            {
            }
        }
        destinationDir = outputDir
        includeEmptyDirs = false
        group = "flansmod internal"
    }
}
fun jarPackTask(modID: String, modNamespace: String, classifier:String, expandTask: Task, expandedDir: File): Jar {
    var suffix: String = classifier
    if(classifier == "dev")
        suffix = ""
    return tasks.create("BuildJar_${modID}_${classifier}", Jar::class.java) {
        val filteredDir:File = file("$projectDir/build/pack/$modID/$classifier")
        val gatherTask: Copy = gatherFilesForPackTask(modID, modNamespace, classifier, expandTask, expandedDir, filteredDir)
        dependsOn(gatherTask)
        from(fileTree(filteredDir))
        {

        }
        includeEmptyDirs = false
        archiveClassifier.set(suffix)
        archiveVersion.set("$mcVersion-$modVersion")
        archiveBaseName.set(modID)
        destinationDirectory.set(file("$projectDir/build/output"))
        group = "flansmod internal"
    }
}
fun gatherFilesForModTask(classifier:String, expandTask: Task, expandedDir: File, outputDir:File): Copy {
    return tasks.create("GatherFiles_flansmod_${classifier}", Copy::class.java) {
        dependsOn(expandTask)
        into("")
        {
            from(fileTree(expandedDir))
            {
                include("**/assets/flansmod/")
                include("**/assets/minecraft/")
                include("**/data/flansmod/")
                include("**/com/flansmod/")
                include("**/flansmod.mcmeta")
                include("**/flansmod.png")
                include("**/META-INF/flansmod.toml")

                exclude("**/com/flansmod/packs")
                exclude("**/com/flansmod/teams")
                exclude("**/data/flansmod/tags/")
                exclude("**/data/flansmod/partial_data/")
                exclude("**/data/flansmod/loot_modifiers/")
            }
            rename { name ->
                if (name == "flansmod.toml")
                    "mods.toml"
                else if (name == "flansmod.mcmeta")
                    "pack.mcmeta"
                else name
            }
        }
        into("data")
        {
            from(fileTree(file("$expandedDir/data/flansmod/partial_data/")))
            {
            }
        }
        destinationDir = outputDir
        includeEmptyDirs = false
        group = "flansmod internal"
    }
}
fun jarModTask(classifier:String, expandTask: Task, expandedDir: File): Jar {

    var suffix: String = classifier
    if(classifier == "dev")
        suffix = ""
    return tasks.create("BuildJar_flansmod_${classifier}", Jar::class.java) {
        val filteredDir:File = file("$projectDir/build/pack/flansmod/$classifier/")
        val gatherTask: Copy = gatherFilesForModTask(classifier, expandTask, expandedDir, filteredDir)
        dependsOn(gatherTask)
        from(fileTree(filteredDir))
        {

        }
        includeEmptyDirs = false
        archiveClassifier.set(suffix)
        archiveVersion.set("$mcVersion-$modVersion")
        archiveBaseName.set("flansmod")
        destinationDirectory.set(file("$projectDir/build/output"))
        group = "flansmod internal"
    }
}



val expandedSourceDir = file("$projectDir/build/expanded/sources")
val expandedDevDir = file("$projectDir/build/expanded/dev")
val expandSourceTask: Copy = expandJarTask(sourceTask, expandedSourceDir)
val expandDevTask: Copy = expandJarTask(reobfTask, expandedDevDir)

fun CreateAllPackTasks(modID: String, modNamespace: String): Pair<Jar, Jar>
{
    return Pair(jarPackTask(modID, modNamespace, "sources", expandSourceTask, expandedSourceDir),
                jarPackTask(modID, modNamespace, "dev", expandDevTask, expandedDevDir))
}



val basicsTasks = CreateAllPackTasks("flansbasicparts", "basics")
val vendersTasks = CreateAllPackTasks("flansvendersgame", "vendersgame")

val modSourceTask: Jar = jarModTask("sources", expandSourceTask, expandedSourceDir)
val modDevTask: Jar = jarModTask("dev", expandDevTask, expandedDevDir)

artifacts {
    add("archives", reobfTask)
    add("archives", sourceTask)

    archives(modSourceTask.outputs.files.singleFile) { builtBy(modSourceTask) }
    archives(modDevTask.outputs.files.singleFile) { builtBy(modDevTask) }
    archives(basicsTasks.first.outputs.files.singleFile) { builtBy(basicsTasks.first) }
    archives(basicsTasks.second.outputs.files.singleFile) { builtBy(basicsTasks.second) }
    archives(vendersTasks.first.outputs.files.singleFile) { builtBy(vendersTasks.first) }
    archives(vendersTasks.second.outputs.files.singleFile) { builtBy(vendersTasks.second) }
}

// -------------------------------- GIT HUB -----------------------------------
tasks.create("generateChangelog") {
    doLast {
        val file = file("CHANGELOG.md")
        val fileContents = StringBuilder(file.readText(Charsets.UTF_8))
        val versionHeader = "\n### $modVersionNoBuild\n"
        if (fileContents.contains(versionHeader)) return@doLast
        val firstNewline = fileContents.indexOf('\n')
        val changelog = getActualChangeList()
        val insertText = "\n$versionHeader$changelog"
        fileContents.insert(firstNewline, insertText)
        file.writeText(fileContents.toString(), Charsets.UTF_8)
    }
}

fun resolveVersionChangelog(): String {
    val changeLogLines = file("CHANGELOG.md").readLines(Charsets.UTF_8)
    val versionHeader = "### $modVersionNoBuild"
    val startLineIndex = changeLogLines.indexOf(versionHeader)
    if (startLineIndex == -1) {
        return "No changelog provided"
    }
    val changelogBuilder = StringBuilder()
    var lineIndex = startLineIndex
    while (lineIndex < changeLogLines.size) {
        val changelogLine = changeLogLines[lineIndex]
        if (changelogLine.isEmpty()) break
        changelogBuilder.append(changelogLine).append("\n")
        lineIndex++
    }
    return changelogBuilder.toString()
}


tasks["build"].dependsOn("generateChangelog")

fun getPrettyCommitDescription(commit: RevCommit): String {
    val closePattern = Regex("(Closes|Fixes) #[0-9]*\\.?")
    val author = commit.authorIdent.name
    val message = commit.fullMessage
            //need to remove messages that close issues from changelog
            .replace(closePattern, "")
            //cut multiple newlines, format them all to linux line endings
            .replace(Regex("(\r?\n){1,}"), "\n")
            //cut squashed commit sub-commits descriptions
            .replace(Regex("\\* [^\\n]*\\n"), "")
            //split commit message on lines, trim each one
            .split('\n').asSequence().map { it.trim() }
            .filterNot { it.isBlank() }
            //cut out lines that are related to merges
            .filter { !it.startsWith("Merge remote-tracking branch") }
            //cut lines that carry too little information
            .filter { it.length > 3 }
            //captialize each line, add . at the end if it's not there
            .map { StringUtils.capitalize(it) }
            .map { if (it.endsWith('.')) it.substring(0, it.length - 1) else it }
            //append author to each line
            .map { "* $it - $author" }.toList()
    return message.joinToString( separator = "\n")
}

fun getCommitFromTag(revWalk: RevWalk, tagObject: RevObject) : RevCommit? {
    return when (tagObject) {
        is RevCommit -> tagObject
        is RevTag -> getCommitFromTag(revWalk, revWalk.parseAny(tagObject.`object`))
        else -> error("Encountered version tag pointing to a non-commit object: $tagObject")
    }
}

fun getActualTagName(tagName: String): String {
    val latestSlash = tagName.lastIndexOf('/')
    return tagName.substring(latestSlash + 1)
}

fun getActualChangeList(): String {
    val revWalk = RevWalk(git.repository)
    val latestTagCommit = git.tagList().call()
            .filter { getActualTagName(it.name).startsWith("v") }
            .mapNotNull { getCommitFromTag(revWalk, revWalk.parseAny(it.objectId)) }
            .maxBy { it.commitTime } ?: error("No previous release version tag found")

    val gitLog = git.log()
    val headCommitId = git.repository.resolve(Constants.HEAD)
    gitLog.addRange(latestTagCommit, headCommitId)
    val commitsBetween = gitLog.call().map { getPrettyCommitDescription(it) }.filterNot { it.isBlank() }
    return commitsBetween.joinToString(separator = "\n")
}

fun getBuildNumber(): String {
    val gitLog = git.log()
    val headCommitId = git.repository.resolve(Constants.HEAD)
    val startCommitId = ObjectId.fromString("a09d3c3091d061c251ddfed6e6242f0ff9c37d8d") // FlansMod119 first commit hash
    gitLog.addRange(startCommitId, headCommitId)
    return gitLog.call().toList().size.toString()
}


// -------------------------------- CURSE FORGE -----------------------------------
fun CurseExtension.project(config: CurseProject.() -> Unit) = CurseProject().also {
    it.config()
    curseProjects.add(it)
}
// has to be called after addArtifact ¯\_(ツ)_/¯
fun CurseProject.relations(config: CurseRelation.() -> Unit) = CurseRelation().also {

    it.config()

    additionalArtifacts.forEach { artifact ->
        artifact.curseRelations = it
    }

    mainArtifact.curseRelations = it
}

fun configureCurseforgeTask(): CurseProject? {
    if (System.getenv("CURSE_API_KEY") != null) {
        val extension = curseforge
        extension.apiKey = System.getenv("CURSE_API_KEY")
        extension.curseGradleOptions.forgeGradleIntegration = false
        return extension.project {
            apiKey = System.getenv("CURSE_API_KEY")
            id = modCurseForgeID
            addGameVersion(mcVersion)
            changelog = file("CHANGELOG.md")
            changelogType = "markdown"
            releaseType = "alpha"

            mainArtifact(modDevTask)
            addArtifact(modSourceTask)

            relations {
                optionalDependency("jei")
            }
        }
    } else {
        println("Skipping curseforge task as there is no api key in the environment")
        return null
    }
}

fun initCurseForgeExtension(): CurseExtension? {
    return if (System.getenv("CURSE_API_KEY") != null) {
        val extension = curseforge
        extension.apiKey = System.getenv("CURSE_API_KEY")
        extension.curseGradleOptions.forgeGradleIntegration = false
        extension
    } else {
        println("Skipping curseforge task as there is no api key in the environment")
        null
    }
}

fun createCurseForgeUploadTask(curseForgeID: String, main: Jar, src: Jar): CurseProject? {
    val curseExtension = initCurseForgeExtension()
    if(curseExtension != null)
    {
        val curseForgeProject = curseExtension.project {
            apiKey = System.getenv("CURSE_API_KEY")
            id = curseForgeID
            addGameVersion(mcVersion)
            changelog = file("CHANGELOG.md")
            changelogType = "markdown"
            releaseType = curseForgeReleaseType

            mainArtifact(main)
            //addArtifact(src) // Don't add sources, it is confusing people

            relations {
                optionalDependency("jei")
            }
        }

        curseForgeProject.uploadTask?.outputs?.upToDateWhen { false }
        return curseForgeProject
    }
    else return null
}

//if (curseforgeProject != null) {
// notificationTask.dependsOn("curseforge")
//}

val modCurseforgeTask            = createCurseForgeUploadTask(modCurseForgeID, modDevTask, modSourceTask)
val basicPartsCurseforgeTask     = createCurseForgeUploadTask(basicsCurseForgeID, basicsTasks.second, basicsTasks.first)
val vendersCurseforgeTask        = createCurseForgeUploadTask(vendersCurseForgeID, vendersTasks.second, vendersTasks.first)




// ------------- MODRINTH ----------------
fun initModrinthExtension(): com.modrinth.minotaur.ModrinthExtension? {
    return if (System.getenv("MODRINTH_TOKEN") != null) {
        val extension = modrinth
        extension.token.set(System.getenv("MODRINTH_TOKEN"))
        extension
    } else {
        println("Skipping Modrinth task as there is no token in the environment")
        null
    }
}
fun createModrinthUploadTask(taskName: String, modrinthSlug: String, main: Jar, src: Jar): TaskModrinthUpload? {
    val modrinthExtension = initModrinthExtension()
    if(modrinthExtension != null)
    {
        val modrinthTask = tasks.create<TaskModrinthUpload>(taskName) {
            doFirst {
                modrinthExtension.projectId.set(modrinthSlug)
                modrinthExtension.versionNumber.set(modVersion)
                modrinthExtension.versionType.set("release")
                modrinthExtension.uploadFile.set(main)
                modrinthExtension.gameVersions.addAll(mcVersion)
                modrinthExtension.loaders.add("forge")
            }
        }

        return modrinthTask
    }
    else return null
}
val modModrinthTask            = createModrinthUploadTask("mod", modModrinthSlug, modDevTask, modSourceTask)
val basicPartsModrinthTask     = createModrinthUploadTask("basics", basicsModrinthSlug, basicsTasks.second, basicsTasks.first)
val vendersModrinthTask        = createModrinthUploadTask("venders", vendersModrinthSlug, vendersTasks.second, vendersTasks.first)





afterEvaluate {
    if(modCurseforgeTask?.uploadTask != null)
        tasks.create("PublishFlansMod[Curse]") {
            dependsOn(modCurseforgeTask.uploadTask)
            group = "flansmod publish"
        }
    if(basicPartsCurseforgeTask?.uploadTask != null)
        tasks.create("PublishBasicParts[Curse]") {
            dependsOn(basicPartsCurseforgeTask.uploadTask)
            group = "flansmod publish"
        }
    if(vendersCurseforgeTask?.uploadTask != null)
        tasks.create("PublishVendersGame[Curse]") {
            dependsOn(vendersCurseforgeTask.uploadTask)
            group = "flansmod publish"
        }

    if(modModrinthTask != null)
        tasks.create("PublishFlansMod[Modrinth]") {
            dependsOn(modModrinthTask)
            group = "flansmod publish"
        }
    if(basicPartsModrinthTask != null)
        tasks.create("PublishBasicParts[Modrinth]") {
            dependsOn(basicPartsModrinthTask)
            group = "flansmod publish"
        }
    if(vendersModrinthTask != null)
        tasks.create("PublishVendersGame[Modrinth]") {
            dependsOn(vendersModrinthTask)
            group = "flansmod publish"
        }

    if(tasks.findByPath("PublishBasicParts[Curse]") != null) {
        tasks.create("PublishAllPacks") {
            dependsOn(tasks.getByName("PublishBasicParts[Curse]"))
            dependsOn(tasks.getByName("PublishVendersGame[Curse]"))
            if(tasks.findByPath("PublishBasicParts[Modrinth]") != null)
            {
                dependsOn(tasks.getByName("PublishBasicParts[Modrinth]"))
                dependsOn(tasks.getByName("PublishVendersGame[Modrinth]"))
            }
            group = "flansmod publish"
        }
        tasks.create("PublishFlansModAndAllPacks") {
            dependsOn(tasks.getByName("PublishFlansMod[Curse]"))
            if(tasks.findByPath("PublishFlansMod[Modrinth]") != null) {
                dependsOn(tasks.getByName("PublishFlansMod[Modrinth]"))
            }
            dependsOn(tasks.getByName("PublishAllPacks"))
            group = "flansmod publish"
        }
    }

    tasks.create("BuildAllPackJars") {
        dependsOn(vendersTasks.second)
        dependsOn(basicsTasks.second)
        group = "flansmod build"
    }
    tasks.create("BuildAllPackSources") {
        dependsOn(vendersTasks.first)
        dependsOn(basicsTasks.first)
        group = "flansmod build"
    }
    tasks.create("BuildAllJars") {
        dependsOn(modDevTask)
        dependsOn(tasks.getByName("BuildAllPackJars"))
        group = "flansmod build"
    }
    tasks.create("BuildAllSources") {
        dependsOn(modSourceTask)
        dependsOn(tasks.getByName("BuildAllPackSources"))
        group = "flansmod build"
    }
    tasks.create("BuildAll") {
        dependsOn(tasks.getByName("BuildAllJars"))
        dependsOn(tasks.getByName("BuildAllSources"))
        group = "flansmod build"
    }

}

publishing {
    publications {
        create("FlansModPublication", MavenPublication::class.java) {
            groupId = project.group as String
            artifactId = "flansmod"
            version = project.version as String

            artifact(jar)
            artifact(sourceTask)
        }
    }
}