build.gradle

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            name "MinecraftForge"
            url "https://maven.minecraftforge.net/"
        }
        maven {
            name "Outlands"
            url "https://maven.outlands.top/releases/"
        }
    }
    dependencies {
        classpath "net.minecraftforge.gradle:ForgeGradle:6.0.+"
    }
}

plugins {
    id "org.jetbrains.gradle.plugin.idea-ext" version "1.1.8"
    id "com.palantir.git-version" version "3.0.0"
}

import com.cleanroommc.gradle.helpers.tasks.*

import groovy.json.JsonBuilder

import java.nio.file.Files
import java.util.zip.ZipFile

import net.minecraftforge.gradle.common.tasks.ApplyBinPatches
import net.minecraftforge.gradle.common.tasks.DownloadMavenArtifact
import net.minecraftforge.gradle.common.tasks.ExtractInheritance
import net.minecraftforge.gradle.common.tasks.ExtractMCPData
import net.minecraftforge.gradle.patcher.tasks.GenerateBinPatches
import net.minecraftforge.gradle.patcher.tasks.ReobfuscateJar
import net.minecraftforge.srgutils.IMappingFile

import org.apache.commons.compress.compressors.lzma.LZMACompressorOutputStream
import org.objectweb.asm.ClassReader
import org.objectweb.asm.ClassVisitor
import org.objectweb.asm.FieldVisitor
import org.objectweb.asm.MethodVisitor
import org.objectweb.asm.Opcodes

def props = project.properties
def sysProps = System.getProperties()
def details = versionDetails()

group 'com.cleanroommc'
//version details.lastTag + (project.hasProperty("release") ?
//        "" : ("+build." + details.commitDistance + (project.hasProperty("run_number") ?
//                (".run." + props.run_number) : "")))
version "0.1.0"

def version_txt = new File(project.projectDir, "version.txt")
version_txt.write(version.toString())
def spec_version = details.lastTag

println "Setting up CatRoom $version"
if (project.hasProperty("run_number")) println("On GitHub runs #" + props.run_number)
println "Java: ${ -> sysProps['java.version']} | JVM: ${ -> sysProps['java.vm.version']} | Vendor: ${ -> sysProps['java.vendor']} | Architecture: ${ -> sysProps['os.arch']}"

// Initialize buildSrc
Util.init()

// Post-Processing
def post_processor = [
    tool: 'net.minecraftforge:mcpcleanup:2.3.2:fatjar',
    repo: 'https://maven.minecraftforge.net/',
    args: ['--input', '{input}', '--output', '{output}']
]

def jvm_arguments = [
    '--add-opens=java.base/jdk.internal.loader=ALL-UNNAMED',
    '--add-opens=java.base/jdk.internal.reflect=ALL-UNNAMED',
    '--add-opens=java.base/java.lang=ALL-UNNAMED',
    '--add-opens=java.base/java.lang.reflect=ALL-UNNAMED'
]

def compiler_jvm_arguments = [
        '--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED',
        '--add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED',
        '-Xlint:-removal', // Suppress Timings deprecation warnings
        '--add-modules=jdk.incubator.vector' // CatRoom - SIMD support
]
// Projects

// MCP
project(':mcp') {
    apply plugin: 'net.minecraftforge.gradle.mcp'
    repositories {
        maven {
            name "outlandsReleases"
            url "https://maven.outlands.top/releases"
        }
        maven {
            name 'MinecraftForge'
            url 'https://maven.minecraftforge.net/'
        }

    }
    mcp {
        config = props.minecraft_version + '-' + props.mcp_version
        pipeline = 'joined'
    }
}

// Minecraft
project(':minecraft') {
    evaluationDependsOn(':mcp')
    apply plugin: 'eclipse'
    apply plugin: 'net.minecraftforge.gradle.patcher'

    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            name "outlandsReleases"
            url "https://maven.outlands.top/releases"
        }
        maven {
            name 'MinecraftForge'
            url 'https://maven.minecraftforge.net/'
        }

    }
    dependencies {
        implementation ('net.minecraftforge:mergetool:0.2.3.3:forge') {
            exclude group: 'org.ow2.asm', module: 'asm-tree'
            exclude group: 'org.ow2.asm', module: 'asm-util'
            exclude group: 'org.ow2.asm', module: 'asm'
        }
    }

    patcher {
        parent = project(':mcp')
        mcVersion = props.minecraft_version
        patchedSrc = file('src/main/java')

        mappings channel: props.mapping_channel, version: props.mapping_version
        processor = post_processor

        runs {
            minecraftClient {
                client true
                taskName 'minecraftClient'
                ideaModule "${rootProject.name}.${project.name}.main"

                main 'net.minecraft.client.main.Main'
                workingDirectory project.file('run')

                args '--gameDir', '.'
                args '--version', props.minecraft_version
                args '--assetsDir', downloadAssets.output
                args '--assetIndex', '{asset_index}'
                args '--accessToken', '0'
            }

            minecraftServer {
                client false
                taskName 'minecraftServer'
                ideaModule "${rootProject.name}.${project.name}.main"

                main 'net.minecraft.server.MinecraftServer'
                workingDirectory project.file('run')
            }
        }
    }
}

// Cleanroom
project(':cleanroom') {
    evaluationDependsOn(':minecraft')
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'net.minecraftforge.gradle.patcher'

    //  = 'net.minecraftforge'
    group = 'com.cleanroommc'
    version = rootProject.version

    compileJava {
        doFirst {
            def target = new File("${rootProject.projectDir}/src/main/java/com/cleanroommc/common/CleanroomVersion.java")
            def template = new File("${rootProject.projectDir}/templates/CleanroomVersion.java")

            target.withWriter { def writer ->
                template.eachLine { def line ->
                    def newLine = line.replace("%VERSION%", versionDetails().lastTag + "-infdev")
                            .replace("%BUILD_VERSION%", rootProject.version.toString())
                    writer.write(newLine + "\n");
                }
            }
        }
    }

    sourceSets {
        main {
            java {
                srcDirs = ["$rootDir/src/main/java"]
            }
            resources {
                srcDirs = ["$rootDir/src/main/resources"]
            }
        }
        test {
            compileClasspath += sourceSets.main.runtimeClasspath
            runtimeClasspath += sourceSets.main.runtimeClasspath
            java {
                srcDirs = ["$rootDir/src/test/java"]
            }
            resources {
                srcDirs = ["$rootDir/src/test/resources"]
            }
        }
        userdev {
            compileClasspath += sourceSets.main.runtimeClasspath
            runtimeClasspath += sourceSets.main.runtimeClasspath
        }
        userdevTest {
            compileClasspath += sourceSets.userdev.runtimeClasspath
            runtimeClasspath += sourceSets.userdev.runtimeClasspath
            compileClasspath += sourceSets.test.runtimeClasspath
            runtimeClasspath += sourceSets.test.runtimeClasspath
        }
    }

    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            name 'Cleanroom Maven'
            url 'https://maven.cleanroommc.com/'
        }
        maven {
            url "https://repo.cleanroommc.com/snapshots"
        }
        maven {
            url "https://maven.outlands.top/releases/"
        }
    }

    ext {
        version_json = project(':mcp').file('build/mcp/downloadJson/version.json')
        lwjglArch = Util.getCurrentArch()
        // Do not change the order unless it is required so
        lwjglLibraries = [
            [
                'lwjgl3-glfw', 'lwjgl3-jemalloc', 'lwjgl3-openal',
                'lwjgl3-opengl', 'lwjgl3-stb', 'lwjgl3-tinyfd', 'lwjgl3'
            ],

            [
                'natives-linux-arm64', 'natives-linux-arm32', 'natives-linux',
                'natives-macos-arm64', 'natives-macos',
                'natives-windows-arm64', 'natives-windows-x86', 'natives-windows'
            ]
        ]
    }

    patcher {
        excs.from file("$rootDir/src/main/resources/forge.exc")
        parent = project(':minecraft')
        patches = file("$rootDir/patches/minecraft")
        patchedSrc = file('src/main/java')
        srgPatches = true
        notchObf = true
        accessTransformer = file("$rootDir/src/main/resources/forge_at.cfg")
        // sideAnnotationStripper = file("$rootDir/src/main/resources/forge.sas")
        processor = post_processor

        runs {

            cleanroomClient {
                client = true
                taskName 'cleanroomClient'
                ideaModule "${rootProject.name}.${project.name}.main"
                main 'com.cleanroommc.boot.MainClient'
                workingDirectory project.file('run')

                environment 'target', 'fmldevclient'
                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLTweaker'
                environment 'mainClass', 'com.cleanroommc.bouncepad.Bouncepad'
                environment 'assetIndex', '{asset_index}'
                environment 'assetDirectory', downloadAssets.output
                environment 'nativesDirectory', extractNatives.output.get().asFile
                environment 'MC_VERSION', props.minecraft_version
                environment 'MCP_VERSION', props.mcp_version
                environment 'MCP_MAPPINGS', '{mcp_mappings}'
                environment 'MCP_TO_SRG', createSrg2Mcp.getOutput().get().getAsFile().getAbsolutePath()
                environment 'FORGE_GROUP', project.group
                environment 'FORGE_VERSION', props.last_forge_version

                jvmArgs jvm_arguments + '-Dmixin.debug.export=true' + '-Dmixin.checks.interfaces=true'
                //jvmArgs jvm_arguments

                // Lazily supply the Mappings target, createSrg2Mcp.getMappings() doesn't get populated until later
                lazyToken 'mcp_mappings', { ->
                    createSrg2Mcp.getMappings().get()
                }

                mods {
                    cleanroom {
                        source sourceSets.main
                    }
                }
            }

            cleanroomTestClient {
                parent runs.cleanroomClient
                taskName 'cleanroomTestClient'

                environment 'MOD_CLASSES', 'dummy' // Needed to work around FG limitation, FG will replace this!

                ideaModule "${rootProject.name}.${project.name}.userdevTest"

                mods {
                    cleanroom {
                        source sourceSets.main
                    }
                    tests {
                        sources sourceSets.test
                    }
                }
            }

            cleanroomServer {
                client false
                taskName 'cleanroomServer'
                ideaModule "${rootProject.name}.${project.name}.main"
                main 'com.cleanroommc.boot.MainServer'
                workingDirectory project.file('run')

                environment 'target', 'fmldevserver'
                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLServerTweaker'
                environment 'mainClass', 'com.cleanroommc.bouncepad.Bouncepad'
                environment 'MC_VERSION', props.minecraft_version
                environment 'MCP_VERSION', props.mcp_version
                environment 'MCP_MAPPINGS', '{mcp_mappings}'
                environment 'MCP_TO_SRG', createSrg2Mcp.getOutput().get().getAsFile().getAbsolutePath()
                environment 'FORGE_GROUP', project.group
                environment 'FORGE_VERSION', props.last_forge_version

                // Lazily supply the Mappings target, createSrg2Mcp.getMappings() doesn't get populated until later
                lazyToken 'mcp_mappings', { ->
                    createSrg2Mcp.getMappings().get()
                }

                mods {
                    cleanroom {
                        source sourceSets.main
                    }
                }
            }

            cleanroomTestServer {
                parent runs.cleanroomServer
                taskName 'cleanroomTestServer'

                environment 'MOD_CLASSES', 'dummy' // Needed to work around FG limitation, FG will replace this!

                ideaModule "${rootProject.name}.${project.name}.userdevTest"

                mods {
                    cleanroom {
                        source sourceSets.main
                    }
                    tests {
                        sources sourceSets.test
                    }
                }
            }
        }

    }

    // Patches
    applyPatches {
        originalPrefix = 'before/'
        modifiedPrefix = 'after/'
        printSummary = true
    }

    genPatches {
        originalPrefix = 'before/'
        modifiedPrefix = 'after/'
    }

    // Dependencies
    configurations {
        all { // LWJGL2 isn't friendly with us, so pye pye
            exclude group: 'org.lwjgl.lwjgl'
            exclude group: 'com.ibm.icu', module: 'icu4j-core-mojang'
            /*exclude group: 'org.apache.commons'
            exclude group: 'org.apache.httpcomponents'
            exclude group: 'it.unimi.dsi'
            exclude group: 'oshi-project'
            exclude group: 'commons-codec'
            exclude group: 'commons-io'
            exclude group: 'commons-logging'
            exclude group: 'com.google.code.findbugs'
            exclude group: 'com.google.code.gson'
            exclude group: 'com.google.guava'*/
        }

        // Don't pull all libraries, if we're missing something, add it to the installer list so the installer knows to download it.
        installer {
            transitive = false
        }
        api.extendsFrom(installer)

        lwjglNatives {
            transitive = false
        }

        testCompile.extendsFrom(lwjglNatives)
    }

    dependencies {
        lwjglLibraries[0].each {
            installer "org.lwjgl3:$it:$props.lwjgl_version"
            runtimeOnly "org.lwjgl3:$it::$lwjglArch"

            lwjglLibraries[1].each { arch ->
                lwjglNatives "org.lwjgl3:$it:$props.lwjgl_version:$arch"
            }
        }

        // TODO: ASM 9.4 required, breaks current Event System when creating classes on-the-fly
        installer "org.ow2.asm:asm:$props.asm_version"
        installer "org.ow2.asm:asm-commons:$props.asm_version"
        installer "org.ow2.asm:asm-tree:$props.asm_version"
        installer "org.ow2.asm:asm-util:$props.asm_version"
        installer "org.ow2.asm:asm-analysis:$props.asm_version"
        // Added back deprecated features for mods to load up properly
        installer "org.ow2.asm:asm-deprecated:$props.asm_deprecated"

        installer "com.cleanroommc:bouncepad:$props.bouncepad_version"

        installer 'com.ibm.icu:icu4j:75.1'

        installer 'org.jline:jline:3.25.0'
        installer 'com.typesafe.akka:akka-actor_2.12:2.8.5'
        installer 'com.typesafe:config:1.4.3'
        // TODO: Move scala away from being defaulted when installing (download on-demand?)
        installer 'org.scala-lang:scala-actors-migration_2.11:1.1.0'
        installer 'org.scala-lang:scala-compiler:2.11.1'
        // We change the version so old installs don't break, as our clone of the jar is different the maven central
        installer 'org.scala-lang.plugins:scala-continuations-library_2.11:1.0.2_mc'
        installer 'org.scala-lang.plugins:scala-continuations-plugin_2.11.1:1.0.2_mc'

        installer 'org.scala-lang:scala-library:2.11.1'
        installer 'org.scala-lang:scala-parser-combinators_2.11:1.0.1'
        installer 'org.scala-lang:scala-reflect:2.11.1'
        installer 'org.scala-lang:scala-swing_2.11:1.0.1'
        installer 'org.scala-lang:scala-xml_2.11:1.0.2'
        installer 'lzma:lzma:0.0.1'
        installer 'java3d:vecmath:1.5.2'
        installer 'net.sf.trove4j:trove4j:3.0.3'
        installer 'org.apache.maven:maven-artifact:3.9.5'
        installer 'net.sf.jopt-simple:jopt-simple:5.0.3'
        installer 'org.apache.commons:commons-lang3:3.13.0'
        installer 'org.apache.commons:commons-compress:1.24.0'
        installer 'org.apache.httpcomponents:httpclient:4.5.14'
        installer 'org.apache.httpcomponents:httpcore:4.4.16'
        installer 'com.github.oshi:oshi-core:6.4.10'
        installer 'net.java.dev.jna:jna:5.14.0'
        installer 'net.java.dev.jna:jna-platform:5.14.0'
        installer 'it.unimi.dsi:fastutil:8.5.12'
        installer 'commons-codec:commons-codec:1.16.0'
        installer 'commons-io:commons-io:2.15.1'
        installer 'commons-logging:commons-logging:1.3.0'
        installer 'com.google.guava:guava:33.0.0-jre'
        installer 'com.google.guava:failureaccess:1.0.2'
        installer 'com.google.code.gson:gson:2.10.1'
        installer 'com.google.code.findbugs:jsr305:3.0.2'

        // TODO: Unpin in 1.18.1 or when Mojang bumps the Log4J version
        installer 'org.apache.logging.log4j:log4j-api:2.22.1'
        installer 'org.apache.logging.log4j:log4j-core:2.22.1'
        installer 'jakarta.annotation:jakarta.annotation-api:2.1.1'
        installer 'jakarta.xml.bind:jakarta.xml.bind-api:4.0.1'
        installer 'jakarta.xml.ws:jakarta.xml.ws-api:4.0.1'
        installer 'jakarta.activation:jakarta.activation-api:2.1.2'
        installer 'org.glassfish.corba:glassfish-corba-omgapi:4.2.5'
        installer 'org.openjdk.nashorn:nashorn-core:15.4'

        // Mixin
        installer 'com.cleanroommc:sponge-mixin:0.16.0+mixin.0.8.5'
        installer annotationProcessor('io.github.llamalad7:mixinextras-common:0.5.0-rc.2')

        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.1'
        testImplementation 'org.junit.vintage:junit-vintage-engine:5.10.1'
        testImplementation 'org.opentest4j:opentest4j:1.3.0' // Needed for junit 5
        testImplementation 'org.hamcrest:hamcrest:2.2' // Needs advanced matching for list order

        // CatServer
        installer 'com.googlecode.json-simple:json-simple:1.1.1'
        installer 'org.yaml:snakeyaml:1.19'
        installer 'net.md-5:SpecialSource:1.11.5'
        installer 'net.md-5:bungeecord-chat:1.16-R0.4'
        installer 'commons-lang:commons-lang:2.6' // Is needed for plugin compatibility
        installer 'org.xerial:sqlite-jdbc:3.21.0.1'
        installer 'mysql:mysql-connector-java:5.1.45'

        // CatRoom
        installer 'net.openhft:affinity:3.23.3'
        installer 'org.slf4j:slf4j-api:2.1.0-alpha1' // Affinity
        installer 'org.slf4j:slf4j-simple:2.1.0-alpha1' // Affinity

        /*
        forgeGradleMcDeps
        +--- com.google.code.findbugs:jsr305:3.0.1
        +--- com.mojang:netty:1.6
        +--- oshi-project:oshi-core:1.1
        |    +--- net.java.dev.jna:jna:3.4.0
        |    \--- net.java.dev.jna:platform:3.4.0
        +--- net.java.dev.jna:jna:3.4.0
        +--- net.java.dev.jna:platform:3.4.0
        +--- com.ibm.icu:icu4j-core-mojang:51.2
        +--- net.sf.jopt-simple:jopt-simple:4.6
        +--- io.netty:netty-all:4.0.23.Final
        +--- com.google.guava:guava:17.0
        +--- org.apache.commons:commons-lang3:3.3.2
        +--- commons-io:commons-io:2.4
        +--- commons-codec:commons-codec:1.9
        +--- net.java.jutils:jutils:1.0.0
        +--- com.google.code.gson:gson:2.2.4
        +--- com.mojang:authlib:1.5.24
        |    +--- com.google.code.findbugs:jsr305:2.0.1 -> 3.0.1
        |    +--- com.google.guava:guava:17.0
        |    +--- org.apache.logging.log4j:log4j-core:2.0-beta9
        |    |    \--- org.apache.logging.log4j:log4j-api:2.0-beta9
        |    +--- commons-io:commons-io:2.4
        |    +--- org.apache.commons:commons-lang3:3.3.2
        |    +--- org.apache.logging.log4j:log4j-api:2.0-beta9
        |    +--- com.google.code.gson:gson:2.2.4
        |    \--- commons-codec:commons-codec:1.9
        +--- com.mojang:realms:1.10.16
        |    +--- org.apache.httpcomponents:httpcore:4.3.2
        |    +--- org.apache.httpcomponents:httpclient:4.3.3
        |    |    +--- org.apache.httpcomponents:httpcore:4.3.2
        |    |    +--- commons-logging:commons-logging:1.1.3
        |    |    \--- commons-codec:commons-codec:1.6 -> 1.9
        |    +--- org.apache.commons:commons-compress:1.8.1
        |    \--- commons-logging:commons-logging:1.1.3
        +--- org.apache.commons:commons-compress:1.8.1
        +--- org.apache.httpcomponents:httpclient:4.3.3 (*)
        +--- commons-logging:commons-logging:1.1.3
        +--- org.apache.httpcomponents:httpcore:4.3.2
        +--- it.unimi.dsi:fastutil:7.0.12_mojang
        +--- org.apache.logging.log4j:log4j-api:2.0-beta9
        +--- org.apache.logging.log4j:log4j-core:2.0-beta9 (*)
        +--- net.minecraft:launchwrapper:1.12
        |    +--- org.ow2.asm:asm-debug-all:5.0.3
        |    +--- org.apache.logging.log4j:log4j-core:2.0-beta9 (*)
        |    +--- net.sf.jopt-simple:jopt-simple:4.5 -> 4.6
        |    +--- org.lwjgl.lwjgl:lwjgl:2.9.1 -> 2.9.4-nightly-20150209
        |    |    +--- org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209
        |    |    \--- net.java.jinput:jinput:2.0.5
        |    |         +--- net.java.jutils:jutils:1.0.0
        |    |         \--- net.java.jinput:jinput-platform:2.0.5
        |    \--- org.apache.logging.log4j:log4j-api:2.0-beta9
        +--- jline:jline:2.13
        |    \--- org.fusesource.jansi:jansi:1.11
        +--- com.google.code.findbugs:jsr305:1.3.9 -> 3.0.1
        +--- org.ow2.asm:asm-debug-all:5.0.3
        +--- com.typesafe.akka:akka-actor_2.11:2.3.3
        |    +--- org.scala-lang:scala-library:2.11.1
        |    \--- com.typesafe:config:1.2.1
        +--- com.typesafe:config:1.2.1
        +--- org.scala-lang:scala-actors-migration_2.11:1.1.0
        |    +--- org.scala-lang:scala-library:2.11.0 -> 2.11.1
        |    +--- org.scala-lang:scala-actors:2.11.0
        |    |    \--- org.scala-lang:scala-library:2.11.0 -> 2.11.1
        |    \--- org.scala-lang.plugins:scala-continuations-library_2.11:1.0.1 -> 1.0.2
        |         \--- org.scala-lang:scala-library:2.11.1
        +--- org.scala-lang:scala-compiler:2.11.1
        |    +--- org.scala-lang:scala-library:2.11.1
        |    +--- org.scala-lang:scala-reflect:2.11.1
        |    |    \--- org.scala-lang:scala-library:2.11.1
        |    +--- org.scala-lang.modules:scala-xml_2.11:1.0.2
        |    |    \--- org.scala-lang:scala-library:2.11.1
        |    \--- org.scala-lang.modules:scala-parser-combinators_2.11:1.0.1
        |         \--- org.scala-lang:scala-library:2.11.0 -> 2.11.1
        +--- org.scala-lang.plugins:scala-continuations-library_2.11:1.0.2 (*)
        +--- org.scala-lang.plugins:scala-continuations-plugin_2.11.1:1.0.2
        |    +--- org.scala-lang:scala-compiler:2.11.1 (*)
        |    \--- org.scala-lang:scala-library:2.11.1
        +--- org.scala-lang:scala-library:2.11.1
        +--- org.scala-lang.modules:scala-parser-combinators_2.11:1.0.1 (*)
        +--- org.scala-lang:scala-reflect:2.11.1 (*)
        +--- org.scala-lang.modules:scala-swing_2.11:1.0.1
        |    \--- org.scala-lang:scala-library:2.11.0 -> 2.11.1
        +--- org.scala-lang.modules:scala-xml_2.11:1.0.2 (*)
        +--- lzma:lzma:0.0.1
        +--- net.sf.trove4j:trove4j:3.0.3
        +--- com.paulscode:codecjorbis:20101023
        |    \--- com.paulscode:soundsystem:20120107
        +--- com.paulscode:codecwav:20101023
        |    \--- com.paulscode:soundsystem:20120107
        +--- com.paulscode:libraryjavasound:20101123
        |    \--- com.paulscode:soundsystem:20120107
        +--- com.paulscode:librarylwjglopenal:20100824
        |    +--- com.paulscode:soundsystem:20120107
        |    \--- org.lwjgl.lwjgl:lwjgl:2.8.3 -> 2.9.4-nightly-20150209 (*)
        +--- com.paulscode:soundsystem:20120107
        +--- net.java.jinput:jinput:2.0.5 (*)
        +--- org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209 (*)
        +--- org.lwjgl.lwjgl:lwjgl_util:2.9.4-nightly-20150209
        |    \--- org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209 (*)
        \--- java3d:vecmath:1.5.2

        forgeGradleMcDepsClient
        +--- com.paulscode:codecjorbis:20101023
        |    \--- com.paulscode:soundsystem:20120107
        +--- com.paulscode:codecwav:20101023
        |    \--- com.paulscode:soundsystem:20120107
        +--- com.paulscode:libraryjavasound:20101123
        |    \--- com.paulscode:soundsystem:20120107
        +--- com.paulscode:librarylwjglopenal:20100824
        |    +--- com.paulscode:soundsystem:20120107
        |    \--- org.lwjgl.lwjgl:lwjgl:2.8.3 -> 2.9.4-nightly-20150209
        |         +--- org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209
        |         \--- net.java.jinput:jinput:2.0.5
        |              +--- net.java.jutils:jutils:1.0.0
        |              \--- net.java.jinput:jinput-platform:2.0.5
        +--- com.paulscode:soundsystem:20120107
        +--- net.java.jinput:jinput:2.0.5 (*)
        +--- org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209 (*)
        +--- org.lwjgl.lwjgl:lwjgl_util:2.9.4-nightly-20150209
        |    \--- org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209 (*)
        \--- java3d:vecmath:1.5.2

        forgeGradleMcNatives
        +--- org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209
        \--- net.java.jinput:jinput-platform:2.0.5

        forgeGradleMcpData
        \--- de.oceanlabs.mcp:mcp:1.11.2

        forgeGradleMcpMappings
        \--- de.oceanlabs.mcp:mcp_snapshot_nodoc:20161220-1.11

        launch4j - The launch4j configuration for this project.
        No dependencies

        BUILD SUCCESSFUL
        */

        // implementation 'net.minecraftforge:legacydev:0.2.3.+:fatjar' TODO: Not Needed

    }

    // TODO: Include?
    def extra_files = [
            rootProject.file('CREDITS.txt'),
            rootProject.file('LICENSE.txt'),
            rootProject.file('LICENSE-Paulscode IBXM Library.txt'),
            rootProject.file('LICENSE-Paulscode SoundSystem CodecIBXM.txt')
    ]

    def changelog = rootProject.file('build/changelog.txt')
    if (changelog.exists()) {
        extra_files += changelog
    }

    // Binary Patching

    // We apply the bin patches we just created to make a jar that is JUST our changes
    ['Client', 'Server', 'Joined'].each { side ->
        def gen = tasks.getByName("gen${side}BinPatches")
        gen.tool = props.binary_patcher
        task "apply${side}BinPatches"(type: ApplyBinPatches, dependsOn: gen) {
            clean = gen.cleanJar
            patch = gen.output
            tool = props.binary_patcher
        }
    }

    task genRuntimeBinPatches(type: GenerateBinPatches, dependsOn: [genClientBinPatches, genServerBinPatches]) {
        tool = props.binary_patcher
    }

    afterEvaluate { p ->
        genRuntimeBinPatches {
            cleanJar = genClientBinPatches.cleanJar
            dirtyJar = genClientBinPatches.dirtyJar
            srg = genClientBinPatches.srg
            patchSets.setFrom(genClientBinPatches.patchSets)
            getArgs().set([
                '--output', '{output}',
                '--patches', '{patches}',
                '--srg', '{srg}',
                // '--legacy',
                '--clean', '{clean}',
                '--dirty', '{dirty}',
                '--prefix', 'binpatch/client',
                '--clean', genServerBinPatches.cleanJar.get().asFile.path,
                '--dirty', genServerBinPatches.dirtyJar.get().asFile.path,
                '--prefix', 'binpatch/server',
            ])
        }
    }

    task downloadLibraries(dependsOn: ':mcp:setupMCP') {
        inputs.file version_json
        doLast {
            def json = version_json.json()
            json.libraries.each { lib ->
                def artifacts = [lib.downloads.artifact] + lib.downloads.get('archiveClassifier', [: ]).values()
                artifacts.each { art ->
                    def target = file('build/libraries/' + art.path)
                    if (!target.exists()) {
                        download {
                            src art.url
                            dest target
                        }
                    }
                }
            }
        }
    }

    task extractInheritance(type: ExtractInheritance, dependsOn: [genJoinedBinPatches, downloadLibraries]) {
        input = genJoinedBinPatches.cleanJar
        doFirst {
            def json = version_json.json()
            json.libraries.each { lib ->
                def artifacts = [lib.downloads.artifact] + lib.downloads.get('archiveClassifier', [: ]).values()
                artifacts.each { art ->
                    def target = file('build/libraries/' + art.path)
                    if (target.exists()) {
                        addLibrary(target)
                    }
                }
            }
        }
    }

    task checkAccessTransformers(dependsOn: genJoinedBinPatches) {
        inputs.file {
            genJoinedBinPatches.cleanJar
        }
        inputs.files patcher.accessTransformers
        doLast {
            def vanilla = [:]
            def zip = new ZipFile(genJoinedBinPatches.cleanJar.get().asFile)
            zip.entries().findAll {
                !it.directory && it.name.endsWith('.class')
            }.each { entry ->
                new ClassReader(zip.getInputStream(entry)).accept(new ClassVisitor(Opcodes.ASM7) {

                    String name

                    void visit(int version, int access, String name, String sig, String superName, String[] interfaces) {
                        this.name = name
                        vanilla[name] = access
                    }

                    FieldVisitor visitField(int access, String name, String desc, String sig, Object value) {
                        vanilla[this.name + ' ' + name] = access
                        return null
                    }

                    MethodVisitor visitMethod(int access, String name, String desc, String sig, String[] excs) {
                        vanilla[this.name + ' ' + name + desc] = access
                        return null
                    }

                }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES)
            }
            patcher.accessTransformers.each { f ->
                TreeMap lines = [:]
                f.eachLine { line ->
                    def idx = line.indexOf('#')
                    if (idx == 0 || line.isEmpty()) {
                        return
                    }
                    def comment = idx == -1 ? null : line.substring(idx)
                    if (idx != -1) {
                        line = line.substring(0, idx - 1)
                    }
                    def (modifier, cls, desc) = (line.trim() + '     ').split(' ', -1)
                    def key = cls + (desc.isEmpty() ? '' : ' ' + desc)
                    def access = vanilla[key.replace('.', '/')]
                    if (access == null) {
                        if ((desc == '*' || desc == '*()') && vanilla[cls.replace('.', '/')] != null) {
                            println('Warning: ' + line)
                        } else {
                            println('Invalid: ' + line)
                            return
                        }
                    }
                    // TODO: Check access actually changes, and expand inheritance?
                    lines[key] = [modifier: modifier, comment: comment]
                }
                f.text = lines.collect { it.value.modifier + ' ' + it.key + (it.value.comment == null ? '' : ' ' + it.value.comment) }.join('\n')
            }
        }
    }

    task checkSAS(dependsOn: extractInheritance) {
        inputs.file {
            extractInheritance.output
        }
        inputs.files patcher.sideAnnotationStrippers
        doLast {
            def json = extractInheritance.output.json()
            patcher.sideAnnotationStrippers.each { f ->
                def lines = []
                f.eachLine { line ->
                    if (line[0] == '\t') {
                        return // Skip any tabbed lines, those are ones we add
                    }
                    def idx = line.indexOf('#')
                    if (idx == 0 || line.isEmpty()) {
                        lines.add(line)
                        return
                    }
                    def comment = idx == -1 ? null : line.substring(idx)
                    if (idx != -1) line = line.substring(0, idx - 1)

                    def(cls, desc) = (line.trim() + '    ').split(' ', -1)
                    cls = cls.replaceAll('\\.', '/')
                    desc = desc.replace('(', ' (')
                    if (desc.isEmpty() || json[cls] == null || json[cls]['methods'] == null || json[cls]['methods'][desc] == null) {
                        println('Invalid: ' + line)
                        return
                    }
                    def mtd = json[cls]['methods'][desc]
                    lines.add(cls + ' ' + desc.replace(' ', '') + (comment == null ? '' : ' ' + comment))
                    def children = json.values().findAll { it.methods != null && it.methods[desc] != null && it.methods[desc].override == cls }
                            .collect { it.name + ' ' + desc.replace(' ', '') } as TreeSet
                    children.each { lines.add('\t' + it) }
                }
                f.text = lines.join('\n')
            }
        }
    }

    task launcherJson(dependsOn: universalJar /*['signUniversalJar']*/) {
        inputs.file {
            universalJar.archivePath
        }
        ext {
            output = file('build/version.json')
            vanilla = project(':mcp').file('build/mcp/downloadJson/version.json')
            timestamp = Util.iso8601Now()
            comment = [
                'Please do not automate the download and installation of Cleanroom.',
                'Our efforts are supported by ads from the download page.'
                // TODO: Donation Page? (Was LexManos')
            ]
            id = "${project.name}-${project.version}"
        }
        inputs.file vanilla
        outputs.file output
        doLast {
            def json_vanilla = vanilla.json()
            def json = [
                _comment_: comment,
                id: id,
                time: timestamp,
                releaseTime: timestamp,
                type: 'release',
                mainClass: 'com.cleanroommc.bouncepad.Bouncepad',
                inheritsFrom: props.minecraft_version,
                logging: { },
                minecraftArguments: [
                    '--username', '${auth_player_name}',
                    '--version', '${version_name}',
                    '--gameDir', '${game_directory}',
                    '--assetsDir', '${assets_root}',
                    '--assetIndex', '${assets_index_name}',
                    '--uuid', '${auth_uuid}',
                    '--accessToken', '${auth_access_token}',
                    '--userType', '${user_type}',
                    '--tweakClass', 'net.minecraftforge.fml.common.launcher.FMLTweaker',
                    '--versionType', 'Forge'
                ].join(' '),
                libraries: [
                    [
                        // Package our universal jar as the 'main' jar Mojang's launcher loads. It will in turn load Forge's regular jars itself.
                        name: "${project.group}:${project.name}:${project.version}",
                        downloads: [
                            artifact: [
                                path: "${project.group.replace('.', '/')}/${project.name}/${project.version}/${project.name}-${project.version}.jar",
                                // Do not include the URL so that the installer/launcher won't grab it. This is also why we don't have the universal classifier
                                url: '',
                                sha1: Util.sha1(universalJar.archivePath),
                                size: universalJar.archivePath.length()
                            ]
                        ]
                    ]
                ]
            ]
            Util.getArtifacts(project, project.configurations.installer, false)
                .each { key, lib ->
                    json.libraries.add(lib)
                }
            Util.getLWJGLNatives(project.configurations.lwjglNatives, project.configurations.testCompile, lwjglLibraries[0], lwjglLibraries[1])
                .each { key, lib ->
                    json.libraries.add(lib)
                }
            output.text = new JsonBuilder(json).toPrettyString()
        }
    }

    task installerJson(dependsOn: [launcherJson, genClientBinPatches/*, createClientSRG, createServerSRG*/]) {
        ext {
            output = file('build/install_profile.json')
            installer_tools = "net.minecraftforge:installertools:$props.installer_tools_version"
        }
        inputs.file universalJar.archivePath
        inputs.file genClientBinPatches.toolJar
        inputs.file launcherJson.output
        outputs.file output
        doLast {
            def libs = [
                "${project.group}:${project.name}:${project.version}": [
                    name: "${project.group}:${project.name}:${project.version}",
                    downloads: [
                        artifact: [
                                path: "${project.group.replace('.', '/')}/${project.name}/${project.version}/${project.name}-${project.version}.jar",
                                // Do not include the URL so that the installer/launcher won't grab it. This is also why we don't have the universal classifier
                                url: '',
                                sha1: Util.sha1(universalJar.archivePath),
                                size: universalJar.archivePath.length()
                        ]
                    ]
                ]
            ]
            def json = [
                _comment_: launcherJson.comment,
                spec: 0,
                profile: project.name,
                version: launcherJson.id,
                icon: 'data:image/png;base64,' + new String(Base64.getEncoder().encode(Files.readAllBytes(rootProject.file('icon.ico').toPath()))),
                json: '/version.json',
                path: "${project.group}:${project.name}:${project.version}",
                logo: '/big_logo.png',
                minecraft: props.minecraft_version,
                welcome: "Welcome to the simple ${project.name.capitalize()} installer.",
                data: [ ] as Map,
                processors: [ ]
            ]
            Util.getClasspath(project, libs, project(':mcp').mcp.config.get().descriptor) // Tell it to download mcp_config
            json.libraries = libs.values().sort { a, b -> a.name.compareTo(b.name) }

            output.text = new JsonBuilder(json).toPrettyString()
        }
    }

    task extractObf2Srg(type: ExtractMCPData, dependsOn: [':mcp:downloadConfig']) {
        config = project(':mcp').downloadConfig.output
    }

    task deobfDataLzma(dependsOn: [extractObf2Srg]) {
        ext {
            output_srg = file('build/deobfDataLzma/data.srg')
            output = file('build/deobfDataLzma/data.lzma')
        }

        doLast {
            IMappingFile.load(extractObf2Srg.output.get().getAsFile()).write(output_srg.toPath(), IMappingFile.Format.SRG, false)
            output_srg.withInputStream { ins ->
                output.withOutputStream { outs ->
                    def lz = new LZMACompressorOutputStream(outs)

                    def i = -1
                    def buf = new byte[0x100]
                    while ((i = ins.read(buf)) != -1)
                        lz.write(buf, 0, i)

                    lz.close()
                }
            }
        }
    }

    universalJar {
        from(extra_files)
        dependsOn(extractObf2Srg)
        from(extractObf2Srg.output) {
            rename {
                "deobf_data-${props.minecraft_version}.tsrg" // TODO: Spacing?
            }
        }
        dependsOn(genRuntimeBinPatches)
        from(genRuntimeBinPatches.output) {
            rename {
                'binpatches.pack.lzma'
            }
        }
        doFirst {
            def classpath = new StringBuilder()
            def artifacts = Util.getArtifacts(project, project.configurations.installer, false)
            artifacts.each { key, lib ->
                classpath.append("libraries/${lib.downloads.artifact.path} ")
            }
            classpath += "minecraft_server.${props.minecraft_version}.jar"
            manifest.attributes([
                'Timestamp'  : new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                'Main-Class' : 'net.minecraftforge.fml.relauncher.ServerLaunchWrapper',
                'Class-Path' : classpath.toString(),
                'Tweak-Class': 'net.minecraftforge.fml.common.launcher.FMLTweaker',
                'Implementation-Version' : "git-CatRoom-${props.minecraft_version}"
            ])
            manifest.attributes([
                'Specification-Title'   : props.title,
                'Specification-Vendor'  : props.vendor,
                'Specification-Version' : spec_version,
                'Implementation-Title'  : project.group,
                'Implementation-Version': props.last_forge_version,
                'Implementation-Vendor' : props.vendor
            ], 'net/minecraftforge/common/')
        }

        archiveClassifier = 'universal'
    }

    task downloadInstaller(type: DownloadMavenArtifact) {
        artifact = 'net.minecraftforge:installer:2.2.+:fatjar'
        changing = true
    }

    task installerJar(type: Zip, dependsOn: [downloadInstaller, installerJson, launcherJson, genClientBinPatches, genServerBinPatches/*, 'signUniversalJar'*/]) {
        archiveClassifier = 'installer'
        archiveExtension = 'jar' //Needs to be Zip task to not override Manifest, so set extension
        destinationDirectory = file('build/libs')
        from(extra_files)
        from(rootProject.file('/src/main/resources/forge_logo.png')) {
            rename { 'big_logo.png' }
        }
        from(rootProject.file('/src/main/resources/url.png'))
        from(universalJar) {
            into("/maven/${project.group.replace('.', '/')}/${project.name}/${project.version}/")
            rename { "${project.name }-${project.version }.jar" }
        }
        from(installerJson.output)
        from(launcherJson.output)
        from(zipTree(downloadInstaller.output)) {
            duplicatesStrategy = 'exclude'
        }
    }

    // TODO: Signing
    /*
    [universalJar, installerJar].each { t ->
        task "sign${t.name.capitalize()}"(type: SignJar, dependsOn: t) {
            onlyIf {
                JAR_SIGNER != null && t.state.failure == null
            }
            def jarsigner = JAR_SIGNER == null ? [: ] : JAR_SIGNER
            alias = 'forge'
            storePass = jarsigner.storepass
            keyPass = jarsigner.keypass
            keyStore = jarsigner.keystore
            inputFile = t.archivePath
            outputFile = t.archivePath
            doFirst {
                project.logger.lifecycle('Signing: ' + inputFile)
            }
        }
        t.finalizedBy(tasks.getByName("sign${t.name.capitalize()}"))
    }
     */

    // TODO: MDK Task

    userdevConfig {
        def artifacts = Util.getArtifacts(project, project.configurations.installer, true)
        artifacts.each { key, lib ->
            libraries.add(lib.name)
        }
        libraries.add('net.minecraftforge:legacydev:0.2.3.+:fatjar')
        universalFilters.add('^(?!binpatches\\.pack\\.lzma$).*$')

        runs {
            client {
                main 'com.cleanroommc.boot.MainClient'

                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLTweaker'
                environment 'mainClass', 'com.cleanroommc.bouncepad.Bouncepad'
                environment 'assetIndex', '{asset_index}'
                environment 'assetDirectory', '{assets_root}'
                environment 'nativesDirectory', '{natives}'
                environment 'MC_VERSION', props.minecraft_version
                environment 'MCP_MAPPINGS', '{mcp_mappings}'
                environment 'MCP_TO_SRG', '{mcp_to_srg}'
                environment 'FORGE_GROUP', project.group
                environment 'FORGE_VERSION', props.last_forge_version
            }

            server {
                main 'com.cleanroommc.boot.MainServer'

                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLServerTweaker'
                environment 'mainClass', 'com.cleanroommc.bouncepad.Bouncepad'
                environment 'MC_VERSION', props.minecraft_version
                environment 'MCP_MAPPINGS', '{mcp_mappings}'
                environment 'MCP_TO_SRG', '{mcp_to_srg}'
                environment 'FORGE_GROUP', project.group
                environment 'FORGE_VERSION', props.last_forge_version
            }
        }
    }

    task userdevExtras(type: Jar) {
        dependsOn classes
        from sourceSets.userdev.output
        archiveClassifier = 'userdev-temp'
    }

    task userdevExtrasReobf(type: ReobfuscateJar) {
        dependsOn userdevExtras, createMcp2Srg
        input = tasks.userdevExtras.archivePath
        srg = tasks.createMcp2Srg.output
    }

    userdevJar {
        dependsOn userdevExtrasReobf
        from(zipTree(tasks.userdevExtrasReobf.output)) {
            into '/inject/'
        }
        from(sourceSets.userdev.output.resourcesDir) {
            into '/inject/'
        }
        archiveClassifier = 'userdev' // Should be 'userdev' but FG5 hardcoded pre1.13 versions to userdev3
    }

    if (project.hasProperty('UPDATE_MAPPINGS')) {
        extractRangeMap {
            sources sourceSets.test.java.srcDirs
        }
        applyRangeMap {
            sources sourceSets.test.java.srcDirs
        }
        sourceSets.test.java.srcDirs.each { extractMappedNew.addTarget it }
    }


    publishing {
        repositories {
            maven {
                name = "outland"
                url = "https://maven.outlands.top/releases"
                credentials(PasswordCredentials)
                authentication {
                    basic(BasicAuthentication)
                }
            }
        }
        publications {
            maven(MavenPublication) {
                groupId = "com.cleanroommc"
                artifactId = "cleanroom"
                version = rootProject.version
                from components.java
                artifact userdevJar
                artifact universalJar
                artifact sourcesJar
                artifact installerJar
            }
        }
    }

    test {
        jvmArgs jvm_arguments + compiler_jvm_arguments
    }
}

tasks.withType(JavaCompile) {
    options.compilerArgs += compiler_jvm_arguments
    options.encoding = 'UTF-8'
}

idea.project.settings.compiler.javac.javacAdditionalOptions = compiler_jvm_arguments.join(' ')

task setup() {
    group 'setup'
    // These must be strings so that we can do lazy resolution. Else we need evaluationDependsOnChildren above
    dependsOn ':minecraft:extractMapped'
    dependsOn ':cleanroom:extractMapped'
}

subprojects {
    tasks.withType(JavaCompile) {
        options.compilerArgs += compiler_jvm_arguments
        options.encoding = 'UTF-8'
    }
}