addon.gradle

//import com.modrinth.minotaur.ModrinthExtension
import org.apache.tools.ant.filters.ReplaceTokens
import java.time.OffsetDateTime
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
import java.util.stream.Collectors
import java.nio.charset.StandardCharsets

def taskGroup = "lwjgl3ify"

def newJavaToolchainSpec = {
    it.vendor = JvmVendorSpec.AZUL
    it.languageVersion = JavaLanguageVersion.of(17)
}

def addOpens = [
    "java.base/java.io=ALL-UNNAMED",
    "java.base/java.lang.invoke=ALL-UNNAMED",
    "java.base/java.lang.ref=ALL-UNNAMED",
    "java.base/java.lang.reflect=ALL-UNNAMED",
    "java.base/java.lang=ALL-UNNAMED",
    "java.base/java.net.spi=ALL-UNNAMED",
    "java.base/java.net=ALL-UNNAMED",
    "java.base/java.nio.channels=ALL-UNNAMED",
    "java.base/java.nio.charset=ALL-UNNAMED",
    "java.base/java.nio.file=ALL-UNNAMED",
    "java.base/java.nio=ALL-UNNAMED",
    "java.base/java.text=ALL-UNNAMED",
    "java.base/java.time.chrono=ALL-UNNAMED",
    "java.base/java.time.format=ALL-UNNAMED",
    "java.base/java.time.temporal=ALL-UNNAMED",
    "java.base/java.time.zone=ALL-UNNAMED",
    "java.base/java.time=ALL-UNNAMED",
    "java.base/java.util.concurrent.atomics=ALL-UNNAMED",
    "java.base/java.util.concurrent.locks=ALL-UNNAMED",
    "java.base/java.util.jar=ALL-UNNAMED",
    "java.base/java.util.zip=ALL-UNNAMED",
    "java.base/java.util=ALL-UNNAMED",
    "java.base/jdk.internal.loader=ALL-UNNAMED",
    "java.base/jdk.internal.misc=ALL-UNNAMED",
    "java.base/jdk.internal.ref=ALL-UNNAMED",
    "java.base/jdk.internal.reflect=ALL-UNNAMED",
    "java.base/sun.nio.ch=ALL-UNNAMED",
    "java.desktop/com.sun.imageio.plugins.png=ALL-UNNAMED",
    "java.desktop/sun.awt.image=ALL-UNNAMED",
    "java.desktop/sun.awt=ALL-UNNAMED",
    "java.sql.rowset/javax.sql.rowset.serial=ALL-UNNAMED",
    "jdk.dynalink/jdk.dynalink.beans=ALL-UNNAMED",
    "jdk.naming.dns/com.sun.jndi.dns=ALL-UNNAMED,java.naming"
]

def extraJavaArgs = [
    "-Dfile.encoding=UTF-8",
    "-Djava.system.class.loader=com.gtnewhorizons.retrofuturabootstrap.RfbSystemClassLoader",
    "-Djava.security.manager=allow"
]

for (openSpec in addOpens) {
    extraJavaArgs += ["--add-opens", openSpec]
}

minecraft {
    injectedTags.put("RECOMMENDED_JAVA_ARGS", extraJavaArgs.stream().collect(Collectors.joining("\t")))
}

Configuration forgePatchesEmbeddedRecompile;
Configuration forgePatchesEmbedded;
Configuration versionJsonElements;

configurations {
    forgePatchesEmbeddedRecompile = create("forgePatchesEmbeddedRecompile") {
        canBeConsumed = false
        canBeResolved = true
    }
    forgePatchesEmbedded = create("forgePatchesEmbedded") {
        canBeConsumed = false
        canBeResolved = true
        extendsFrom(forgePatchesEmbeddedRecompile)
    }
    versionJsonElements = create("versionJsonElements") {
        canBeConsumed = false
        canBeResolved = false
    }
    patchedMinecraft { extendsFrom(forgePatchesEmbeddedRecompile) }
    compileClasspath { extendsFrom(forgePatchesEmbedded) }
    runtimeClasspath { extendsFrom(forgePatchesEmbedded) }
    shadowImplementation
}

SourceSet hotswapSet;
SourceSet relauncherStubSet;

sourceSets {
    create("util")
    hotswapSet = create("hotswap")
    relauncherStubSet = create("relauncherStub") {
        compileClasspath += forgePatchesEmbedded + configurations.shadowImplementation
    }
    main {
        java {
            srcDir("src/generated/java")
        }
    }
}

tasks.named(hotswapSet.compileJavaTaskName).configure {
    javaCompiler = javaToolchains.compilerFor(newJavaToolchainSpec)
    sourceCompatibility = JavaVersion.VERSION_17.majorVersion
    targetCompatibility = JavaVersion.VERSION_17.majorVersion
}

tasks.named(relauncherStubSet.compileJavaTaskName).configure {
    javaCompiler = javaToolchains.compilerFor(newJavaToolchainSpec)
    sourceCompatibility = JavaVersion.VERSION_17.majorVersion
    targetCompatibility = JavaVersion.VERSION_17.majorVersion
    options.release = 17
}

tasks.createMcLauncherFiles {
    // Override main class
    replacementTokens.put("@@BOUNCERCLIENT@@", "com.gtnewhorizons.retrofuturabootstrap.Main")
    replacementTokens.put("@@BOUNCERSERVER@@", "com.gtnewhorizons.retrofuturabootstrap.Main")
}

def forgePatchesJar = tasks.register('forgePatchesJar', Jar) {
    dependsOn(tasks.compileJava)
    group = taskGroup
    description = "Packages the forgePatches jar"
    reproducibleFileOrder = true
    preserveFileTimestamps = false
    duplicatesStrategy = "EXCLUDE"
    // Bootleg shadow jar
    forgePatchesEmbedded.resolve().forEach { dep ->
        from(zipTree(dep)) {
            filesMatching("META-INF/*") {
                name = "${dep.name}-${this.name}"
            }
            exclude 'META-INF/services/javax.script.ScriptEngineFactory'
        }
    }
        from(resources.text.fromString("org.openjdk.nashorn.api.scripting.NashornScriptEngineFactory\norg.mvel2.jsr223.MvelScriptEngineFactory").asFile(StandardCharsets.UTF_8.name())) {
        rename { return "META-INF/services/javax.script.ScriptEngineFactory" }
    }
    exclude("module-info.class")
    exclude("META-INF/versions/9/module-info.class")
    exclude("log4j2.xml")
    from(sourceSets.main.output.classesDirs) {
        include("me/eigenraven/lwjgl3ify/rfb/entry/ServerMain.class")
    }
    from(relauncherStubSet.output)
    inputs.property("version", project.version.toString())
    from(resources.text.fromString(project.version.toString()).asFile()) {
        rename {"META-INF/lwjgl3ify-forgePatches-version.txt"}
    }

    archiveClassifier.set("forgePatches")
    manifest {
        def libraryList = [
            "libraries/com/typesafe/akka/akka-actor_2.11/2.3.3/akka-actor_2.11-2.3.3.jar",
            "libraries/com/typesafe/config/1.2.1/config-1.2.1.jar",
            "libraries/org/jline/jline/3.5.1/jline-3.5.1.jar",
            "libraries/org/scala-lang/scala-actors-migration_2.11/1.1.0/scala-actors-migration_2.11-1.1.0.jar",
            "libraries/org/scala-lang/scala-compiler/2.11.1/scala-compiler-2.11.1.jar",
            "libraries/org/scala-lang/plugins/scala-continuations-library_2.11/1.0.2/scala-continuations-library_2.11-1.0.2.jar",
            "libraries/org/scala-lang/plugins/scala-continuations-plugin_2.11.1/1.0.2/scala-continuations-plugin_2.11.1-1.0.2.jar",
            "libraries/org/scala-lang/scala-library/2.11.1/scala-library-2.11.1.jar",
            "libraries/org/scala-lang/scala-parser-combinators_2.11/1.0.1/scala-parser-combinators_2.11-1.0.1.jar",
            "libraries/org/scala-lang/scala-reflect/2.11.1/scala-reflect-2.11.1.jar",
            "libraries/org/scala-lang/scala-swing_2.11/1.0.1/scala-swing_2.11-1.0.1.jar",
            "libraries/org/scala-lang/scala-xml_2.11/1.0.2/scala-xml_2.11-1.0.2.jar",
            "libraries/lzma/lzma/0.0.1/lzma-0.0.1.jar",
            "libraries/java3d/vecmath/1.5.2/vecmath-1.5.2.jar",
            "libraries/net/sf/trove4j/trove4j/3.0.3/trove4j-3.0.3.jar",
            "libraries/org/apache/maven/maven-artifact/3.5.3/maven-artifact-3.5.3.jar",
            "libraries/net/sf/jopt-simple/jopt-simple/5.0.3/jopt-simple-5.0.3.jar",
            "libraries/org/apache/logging/log4j/log4j-api/2.15.0/log4j-api-2.15.0.jar",
            "libraries/org/apache/logging/log4j/log4j-core/2.15.0/log4j-core-2.15.0.jar",
            "forge-1.12.2-14.23.5.2860.jar",
            "minecraft_server.1.12.2.jar"
        ]
        attributes(
            [
                "Class-Path": libraryList.stream().collect(Collectors.joining(" ")),
                "Add-Opens": addOpens.stream().map{ it.split("=")[0]}.collect(Collectors.joining(" ")),
                "Main-Class": "me.eigenraven.lwjgl3ify.rfb.entry.ServerMain"
            ]
        )
    }
}

def mmcInstanceFilesZip = tasks.register("mmcInstanceFiles", Zip) {
    group = taskGroup
    description = "Packages the MultiMC patches"
    dependsOn(forgePatchesJar)
    archiveClassifier.set("multimc")
    from(project.file("prism-libraries/"))
    from(forgePatchesJar) {
        into("libraries/")
    }
    exclude("META-INF", "META-INF/**")
    filesMatching(
        [
            "mmc-pack.json",
            "patches/me.eigenraven.lwjgl3ify.forgepatches.json",
            "patches/me.eigenraven.lwjgl3ify.launchargs.json"
        ]
    ) {
        expand(
            [
                "version": project . version ,
                "jvmArgs": extraJavaArgs.stream().map({ '"' + it + '"' }).collect(Collectors.joining(", "))
            ]
        )
    }
}

def versionJsonPath = layout.buildDirectory.file("libs/version.json").get().asFile

def versionJsonFile = tasks.register("versionJson") {
    group = taskGroup
    description = "Generates the vanilla launcher version.json file"
    inputs.file("launcher-metadata/version.json")
    inputs.property("version", project.version)
    inputs.property("jvmArgs", extraJavaArgs)
    outputs.file(versionJsonPath)
    doLast {
        versionJsonPath.parentFile.mkdirs()
        copy {
            from("launcher-metadata/version.json")
            into(versionJsonPath.parentFile)
            filter(
                ["tokens": [
                    "version": project.version,
                    "jvmArgs": extraJavaArgs.stream().map({ '"' + it + '"' }).collect(Collectors.joining(", ")),
                    "time": DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssXXX")
                        .format(OffsetDateTime.now(ZoneOffset.UTC))
                ]],
                ReplaceTokens.class
            )
        }
    }
}

tasks.shadowJar {
    dependsOn(forgePatchesJar, versionJsonFile)

    from(hotswapSet.output)
    // Use .zip because shadow unpacks .jar archives into the parent jar
    from(forgePatchesJar) {
        rename { "me/eigenraven/lwjgl3ify/relauncher/forgePatches.zip" }
    }
    from(versionJsonFile) {
        rename { "me/eigenraven/lwjgl3ify/relauncher/version.json" }
    }
}

def versionJsonArtifact = artifacts.add("versionJsonElements", versionJsonPath) {
    type = "json"
    classifier = "version"
    builtBy(versionJsonFile)
}

tasks.named("assemble").configure {
    dependsOn(forgePatchesJar)
    dependsOn(mmcInstanceFilesZip)
    dependsOn(versionJsonFile)
}

def runComparisonTool = tasks.register("runComparisonTool", JavaExec) {
    group = taskGroup
    description = "Runs the 2<->3 mapping generation"
    classpath(sourceSets.named("util").map { it.runtimeClasspath })
    dependsOn("jar")
    mainClass.set("me.eigenraven.lwjgl3ify.ComparisonTool")
    minHeapSize = "2G"
    maxHeapSize = "2G"
}

tasks.processResources {
    inputs.property("version", project.version.toString())
    filesMatching("META-INF/rfb-plugin/*") {
        expand(["version": project.version.toString()])
    }
}

afterEvaluate {
    // Main buildscript sets up publishing and curseforge after addon.gradle is applied
    publishing.publications.named("maven", MavenPublication) {
        artifact(forgePatchesJar)
        artifact(mmcInstanceFilesZip)
        artifact(versionJsonArtifact)
    }

    pluginManager.withPlugin("net.darkhax.curseforgegradle") {
        tasks.curseforge {
            dependsOn(forgePatchesJar)
            def mainArtifact = uploadArtifacts[0]
            mainArtifact.withAdditionalFile(forgePatchesJar.get().archiveFile.get().asFile)
            mainArtifact.additionalArtifacts.forEach { additionalArtifact ->
                additionalArtifact.changelogType = mainArtifact.changelogType
                additionalArtifact.changelog = mainArtifact.changelog

            }
        }
    }
}

runComparisonTool.configure {
    def lwjgl2Zips = configurations.lwjgl2Classpath.resolve().stream()
        .filter { !it.name.contains("natives") && !it.path.contains("net.java.j") }
    def lwjgl3Zips = configurations.lwjgl3Classpath.resolve().stream().filter { !it.name.contains("natives") }
    def lwjgl2Args = lwjgl2Zips.map({ "--2:" + it }).collect(Collectors.toList())
    def lwjgl3Args = lwjgl3Zips.map({ "--3:" + it }).collect(Collectors.toList());
    def allArgs = lwjgl2Args + lwjgl3Args + ["--M:" + tasks.jar.archiveFile.asFile.get().path]
    args(allArgs)
}

def veryNewJavaToolchainSpec = {
    it.vendor = JvmVendorSpec.AZUL
    it.languageVersion = JavaLanguageVersion.of(21)
}

def newJavaLauncher = javaToolchains.launcherFor(veryNewJavaToolchainSpec)

for (jarTask in ["jar", "shadowJar", "forgePatchesJar"]) {
    tasks.named(jarTask, Jar).configure {
        manifest {
            attributes(["Multi-Release": true])
        }
    }
}

for (runTask in [tasks.runClient, tasks.runServer]) {
    runTask.configure {
        classpath = files(forgePatchesJar) + classpath
        extraJvmArgs = extraJavaArgs
        javaLauncher = newJavaLauncher
    }
}

for (runTask in [tasks.runObfClient, tasks.runObfServer]) {
    runTask.configure {
        classpath = files(forgePatchesJar) + classpath
        extraJvmArgs = extraJavaArgs
        javaLauncher = newJavaLauncher
    }
}

def originalLaunchWrapperPath = project.layout.buildDirectory.file("launchwrapper-1.12.jar").get().asFile

//import com.gtnewhorizons.retrofuturagradle.minecraft.RunMinecraftTask
//import com.gtnewhorizons.retrofuturagradle.util.Distribution
/*def runWithRelauncher = tasks.register("runClientWithRelauncher", com.gtnewhorizons.retrofuturagradle.minecraft.RunMinecraftTask.class, Distribution.CLIENT, gradle)
runWithRelauncher.configure {
    setup(project)
    group = "lwjgl3ify"
    description = "Runs the deobfuscated client while triggering the relauncher"
    dependsOn(
        sourceSets.mcLauncher.map { it.classesTaskName },
        tasks.downloadVanillaAssets,
        tasks.packagePatchedMc,
        tasks.reobfJar,
        "jar"
    )

    username = minecraft.username
    userUUID = minecraft.userUUID
    lwjglVersion = 2

    systemProperty("gradlestart.bouncerClient", "net.minecraft.launchwrapper.Launch")

    classpath(tasks.packageMcLauncher)
    classpath(tasks.packagePatchedMc)
    classpath(originalLaunchWrapperPath)
    classpath(configurations.patchedMinecraft)
    classpath(tasks.reobfJar)
    classpath(configurations.runtimeClasspath)
    mainClass = "GradleStart"

    doFirst {
        download.run {
            src("https://libraries.minecraft.net/net/minecraft/launchwrapper/1.12/launchwrapper-1.12.jar")
            dest(originalLaunchWrapperPath)
            overwrite(false)
        }
    }
}*/

tasks.runObfClient {
    mainClass.set("com.gtnewhorizons.retrofuturabootstrap.Main")
}

tasks.runObfServer {
    tweakClasses.set([])
}

// Regular runClient/runServer tasks run in Java 17 in this project.
//tasks.runClient17 { enabled = false }
//tasks.runClient21 { enabled = false }
//tasks.runServer17 { enabled = false }
//tasks.runServer21 { enabled = false }

tasks.jar {
    manifest.attributes.put("TweakClass", "me.eigenraven.lwjgl3ify.relauncher.Lwjgl3ifyRelauncherTweaker")
}

tasks.shadowJar {
    manifest.attributes.put("TweakClass", "me.eigenraven.lwjgl3ify.relauncher.Lwjgl3ifyRelauncherTweaker")
}

pluginManager.withPlugin("com.modrinth.minotaur") {
    def modrinth = project.extensions.findByName("modrinth")
    modrinth.additionalFiles.add(forgePatchesJar)
    tasks.named("modrinth") {
        dependsOn(forgePatchesJar)
    }
}