build.gradle

buildscript {
	repositories {
		mavenCentral()
		maven {
			name "Fabric Repository"
			url 'https://maven.fabricmc.net'
		}
	}
	dependencies {
		classpath "cuchaz:enigma:$project.enigma_version"
		classpath "cuchaz:enigma-cli:$project.enigma_version"
		classpath "net.fabricmc:stitch:0.4.6+build.74"
		classpath "commons-io:commons-io:2.6"
		classpath "com.google.guava:guava:28.0-jre"
		classpath 'net.fabricmc:tiny-remapper:+'
		classpath 'net.fabricmc:mapping-io:0.3.0'
		classpath "net.fabricmc:name-proposal:$project.name_proposal_version"
	}
}

plugins {
	id 'de.undercouch.download' version '3.4.3'
	id 'base'
	id 'maven-publish'
}

def minecraft_version = "c0.30_01c"

def ENV = System.getenv()
// Fetch build number from Jenkins
def build_number = ENV.BUILD_NUMBER ?: "local"

def yarnVersion = "${minecraft_version}+build.$build_number"

repositories {
	mavenCentral()
	mavenLocal()
	maven {
		name "Fabric Repository"
		url 'https://maven.fabricmc.net'
	}
}

configurations {
	enigmaRuntime {
		resolutionStrategy {
			cacheDynamicVersionsFor 0, "seconds"
			cacheChangingModulesFor 0, "seconds"
		}
	}
}

dependencies {
	enigmaRuntime "net.fabricmc:name-proposal:$project.name_proposal_version"
	enigmaRuntime("cuchaz:enigma-swing:$project.enigma_version") {
		attributes {
			attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling, Bundling.SHADOWED))
		}
	}
}

def setupGroup = "jar setup"
def yarnGroup = "yarn"
def buildMappingGroup = "mapping build"
def mapJarGroup = "jar mapping"
def mappingsDir = file("mappings")
def cacheFilesMinecraft = file(".gradle/minecraft")
def tempDir = file(".gradle/temp")
def intermediaryJar = file("${minecraft_version}-intermediary.jar")
def yarnJar = file("${minecraft_version}-yarn.jar")
def namedJar = file("${minecraft_version}-named.jar")
def versionFile = new File(cacheFilesMinecraft, "${minecraft_version}.json")
def clientJar = new File(cacheFilesMinecraft, "${minecraft_version}-client.jar")
def libraries = new File(cacheFilesMinecraft, "libraries")
def libs = new File("build/libs/")


import com.google.common.hash.Hashing
import cuchaz.enigma.command.CheckMappingsCommand
import cuchaz.enigma.command.ComposeMappingsCommand
import cuchaz.enigma.command.ConvertMappingsCommand
import cuchaz.enigma.command.MapSpecializedMethodsCommand
import groovy.io.FileType
import groovy.json.JsonSlurper
import juuxel.chocostitch.CommandFixNesting
import net.fabricmc.mappingio.MappingReader
import net.fabricmc.mappingio.adapter.MappingNsCompleter
import net.fabricmc.mappingio.adapter.MappingDstNsReorder
import net.fabricmc.mappingio.format.Tiny2Writer
import net.fabricmc.mappingio.tree.MemoryMappingTree
import net.fabricmc.nameproposal.MappingNameCompleter
import net.fabricmc.stitch.commands.CommandMergeTiny
import net.fabricmc.stitch.commands.CommandProposeFieldNames
import net.fabricmc.stitch.commands.CommandReorderTiny
import net.fabricmc.stitch.commands.CommandRewriteIntermediary
import net.fabricmc.tinyremapper.OutputConsumerPath
import net.fabricmc.tinyremapper.TinyRemapper
import net.fabricmc.tinyremapper.TinyUtils
import org.apache.commons.io.FileUtils

import java.nio.charset.StandardCharsets
import java.nio.file.Files
import java.nio.file.StandardCopyOption
import java.util.zip.GZIPOutputStream

boolean validateChecksum(File file, String checksum) {
	if (file != null) {
		def hash = com.google.common.io.Files.asByteSource(file).hash(Hashing.sha1())
		def builder = new StringBuilder()
		hash.asBytes().each {
			builder.append(Integer.toString((it & 0xFF) + 0x100, 16).substring(1))
		}
		return builder.toString().equals(checksum)
	}
	return false
}

task downloadVersionsManifest {
	group = setupGroup
	//inputs.property "mc_ver", minecraft_version
	inputs.property "currenttime", new Date()
	def manifestFile = new File(cacheFilesMinecraft, "version_manifest.json")
	outputs.file(manifestFile)
	doLast {
		logger.lifecycle(":downloading minecraft versions manifest")
		FileUtils.copyURLToFile(new URL("https://launchermeta.mojang.com/mc/game/version_manifest.json"), manifestFile)
	}
}

def getManifestVersion(File manifestFile, String minecraft_version) {
	def manifest = manifestFile.exists() ? new JsonSlurper().parseText(FileUtils.readFileToString(manifestFile)) : null
	return manifest != null ? manifest.versions.stream().filter({
		it.id.equals(minecraft_version)
	}).findFirst() : java.util.Optional.empty()
}

task downloadWantedVersionManifest(dependsOn: downloadVersionsManifest) {
	group = setupGroup
	def manifestFile = downloadVersionsManifest.outputs.files.singleFile
	def manifestVersion = getManifestVersion(manifestFile, minecraft_version)

	//have to grab the release time as there's a current timestamp on each element?!
	inputs.property "releaseTime", manifestVersion.isPresent() ? manifestVersion.get().releaseTime : -1

	outputs.file versionFile

	doLast {
		manifestVersion = getManifestVersion(manifestFile, minecraft_version)
		//nb need to re-read here in case it didn't exist before
		if (manifestVersion.isPresent() || versionFile.exists()) {

			if (manifestVersion.isPresent()) {
				FileUtils.copyURLToFile(new URL(manifestVersion.get().url), versionFile)
			}
		} else {
			throw new RuntimeException("No version data for Minecraft version ${minecraft_version}")
		}
	}

}

task downloadMcJars(dependsOn: downloadWantedVersionManifest) {
	group = setupGroup
	inputs.files versionFile

	outputs.files(clientJar)

	outputs.upToDateWhen {
		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))
		//return clientJar.exists() && serverJar.exists() && validateChecksum(clientJar, version.downloads.client.sha1) && validateChecksum(serverJar, version.downloads.server.sha1)
		return clientJar.exists() && validateChecksum(clientJar, version.downloads.client.sha1)
	}

	doLast {
		if (!versionFile.exists()) {
			throw new RuntimeException("Can't download the jars without the ${versionFile.name} file!")
		}

		//reload in case it changed
		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))

		logger.lifecycle(":downloading minecraft jars")

		if (!clientJar.exists() || !validateChecksum(clientJar, version.downloads.client.sha1)) {
			logger.lifecycle(":downloading minecraft client")
			FileUtils.copyURLToFile(new URL(version.downloads.client.url), clientJar)
		}
	}
}

class FakeDownload extends DefaultTask {
	@InputFile File src
	@OutputFile File dest

	@TaskAction
	def run() {
		Files.copy(src.toPath(), dest.toPath(), StandardCopyOption.REPLACE_EXISTING)
	}
}

task downloadIntermediary(type: FakeDownload) {
	def destination = new File(cacheFilesMinecraft, "${minecraft_version}-intermediary.tiny")
	group = buildMappingGroup
	src = file("intermediary/${minecraft_version}.tiny")
	dest = destination
}

task downloadMcLibs(dependsOn: downloadWantedVersionManifest) {
	group = setupGroup
	inputs.files versionFile

	outputs.dir(libraries)

	outputs.upToDateWhen { false }

	doLast {
		if (!versionFile.exists()) {
			throw new RuntimeException("Can't download the jars without the ${versionFile.name} file!")
		}

		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile, StandardCharsets.UTF_8))

		logger.lifecycle(":downloading minecraft libraries")

		if (!libraries.exists()) {
			libraries.mkdirs()
		}

		version.libraries.each {
			def artifactData = it.downloads.artifact
			if (artifactData != null) { // not available for classic natives, but they aren't needed for mapping anyway
				def downloadUrl = artifactData.url

				download {
					src downloadUrl
					dest new File(libraries, downloadUrl.substring(downloadUrl.lastIndexOf("/") + 1))
					overwrite false
				}
			}
		}
	}
}

task invertIntermediary(dependsOn: downloadIntermediary, type: FileOutput) {
	group = buildMappingGroup
	def v1Input = downloadIntermediary.dest

	output = new File(cacheFilesMinecraft, "${minecraft_version}-intermediary-inverted.tiny")
	outputs.file(output)

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":building inverted intermediary")

		String[] v1Args = [
				v1Input.getAbsolutePath(),
				output.getAbsolutePath(),
				"intermediary", "official"
		]

		new CommandReorderTiny().run(v1Args)
	}
}

task patchIntermediary(dependsOn: [downloadMcJars, downloadIntermediary]) {
	group = buildMappingGroup
	def intermediaryTinyInput = downloadIntermediary.dest

	def outputFile = new File(cacheFilesMinecraft, "${minecraft_version}-intermediary-full.tiny")
	outputs.file(outputFile)

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":patching intermediary")
		String[] args = [
				clientJar.getAbsolutePath(),
				intermediaryTinyInput.getAbsolutePath(),
				outputFile.getAbsolutePath(),
				"--writeAll"
		]

		new CommandRewriteIntermediary().run(args)
	}
}

task mapIntermediaryJar(dependsOn: [downloadMcLibs, downloadIntermediary, downloadMcJars]) {
	group = mapJarGroup
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file(intermediaryJar)

	//Force the task to always run
	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":mapping minecraft to intermediary")
		def tinyInput = downloadIntermediary.dest
		mapJar(intermediaryJar, clientJar, tinyInput, libraries, "official", "intermediary")
		CommandFixNesting.run(intermediaryJar)
	}
}

task setupYarn(dependsOn: mapIntermediaryJar) {
	group = yarnGroup
}

task yarn(dependsOn: setupYarn, type: JavaExec) {
	group = yarnGroup
	mainClass = 'cuchaz.enigma.gui.Main'
	classpath = configurations.enigmaRuntime
	args '-jar'
	args intermediaryJar.absolutePath
	args '-mappings'
	args mappingsDir.absolutePath
	args '-profile'
	args 'enigma_profile.json'
	maxHeapSize = '2G'
}

task checkMappings {
	group = buildMappingGroup
	inputs.dir mappingsDir
	doLast {
		logger.lifecycle(":checking mappings")

		String[] args = [
				clientJar.getAbsolutePath(),
				mappingsDir.getAbsolutePath()
		]

		new CheckMappingsCommand().run(args)
	}
}

task buildYarnTiny(dependsOn: mapIntermediaryJar, type: WithV2FileOutput) {
	group = buildMappingGroup
	inputs.dir mappingsDir
	if (!libs.exists()) {
		libs.mkdirs()
	}

	v1Output = new File(tempDir, "yarn-mappings.tiny")
	v2Output = new File(tempDir, "yarn-mappings-v2.tiny")

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":generating tiny mappings")

		new MapSpecializedMethodsCommand().run(
			intermediaryJar.getAbsolutePath(),
			"enigma",
			mappingsDir.getAbsolutePath(),
			"tinyv2:intermediary:named",
			v2Output.getAbsolutePath()
		)

		new ConvertMappingsCommand().run(
			"tinyv2",
			v2Output.getAbsolutePath(),
			"tiny:intermediary:named",
			v1Output.getAbsolutePath())
	}
}

task mergeTiny(dependsOn: ["buildYarnTiny", "invertIntermediary"], type: FileOutput) {
	group = buildMappingGroup
	def yarnTinyInput = buildYarnTiny.v1Output
	def intermediaryTinyInput = invertIntermediary.output

	def unorderedResultMappings = new File(tempDir, "mappings-unordered.tiny")
	output = new File(tempDir, "mappings.tiny")
	outputs.file(output)

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":merging yarn and intermediary")
		String[] args = [
				intermediaryTinyInput.getAbsolutePath(),
				yarnTinyInput.getAbsolutePath(),
				unorderedResultMappings.getAbsolutePath(),
				"intermediary",
				"official"
		]

		new CommandMergeTiny().run(args)

		logger.lifecycle(":reordering merged intermediary")
		String[] args2 = [
				unorderedResultMappings.getAbsolutePath(),
				output.getAbsolutePath(),
				"official", "intermediary", "named"
		]

		new CommandReorderTiny().run(args2)
	}
}

task tinyJar(type: Jar, dependsOn: mergeTiny) {
	group = buildMappingGroup
	outputs.upToDateWhen { false }
	archiveFileName = "yarn-${yarnVersion}.jar"
	destinationDirectory.set(file("build/libs"))
	classifier = ""
	from(mergeTiny.output) {
		rename { "mappings/mappings.tiny" }
	}
}

task compressTiny(dependsOn: [tinyJar, mergeTiny], type: FileOutput) {
	group = buildMappingGroup
	def outputFile = new File(libs, "yarn-tiny-${yarnVersion}.gz")
	outputs.file(outputFile)
	output = outputFile

	def inputFile = mergeTiny.output

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":compressing tiny mappings")

		def buffer = new byte[1024]
		def fileOutputStream = new FileOutputStream(outputFile)
		def outputStream = new GZIPOutputStream(fileOutputStream)
		def fileInputStream = new FileInputStream(inputFile)

		def length
		while ((length = fileInputStream.read(buffer)) > 0) {
			outputStream.write(buffer, 0, length)
		}

		fileInputStream.close()
		outputStream.finish()
		outputStream.close()
	}
}

clean.doFirst {
	delete tempDir, cacheFilesMinecraft
}

tasks.build.dependsOn "compressTiny","tinyJar","v2UnmergedYarnJar"

task mapYarnJar(dependsOn: [compressTiny, mapIntermediaryJar]) {
	group = mapJarGroup
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file(yarnJar)

	//Force the task to always run
	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":mapping minecraft to yarn")

		File tinyInput = compressTiny.output
		mapJar(yarnJar, intermediaryJar, tinyInput, libraries, "intermediary", "named")
	}
}

task exportMappingsOfficial(dependsOn: downloadIntermediary) {
	def composeInput = downloadIntermediary.dest

	doLast {
		logger.lifecycle(":exporting mappings")
		String[] args = [
				"tiny",
				composeInput.getAbsolutePath(),
				"enigma",
				file("mappings/").getAbsolutePath(),
				"enigma",
				file("mappings_official/").getAbsolutePath(),
				"right"
		]

		new ComposeMappingsCommand().run(args)
	}
}

task importMappingsOfficial(dependsOn: invertIntermediary) {
	def composeInput = invertIntermediary.output

	doLast {
		logger.lifecycle(":importing mappings")
		String[] args = [
				"tiny",
				composeInput.getAbsolutePath(),
				"enigma",
				file("mappings_official/").getAbsolutePath(),
				"enigma",
				file("mappings/").getAbsolutePath(),
				"right"
		]

		new ComposeMappingsCommand().run(args)
	}
}

task buildTinyWithEnum(dependsOn: "mergeTiny", type: FileOutput) {
	group = buildMappingGroup
	def noEnum = mergeTiny.output
	output = new File(tempDir, "named-with-enum.tiny")

	outputs.file(output)
	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":seeking auto-mappable fields")
		String[] argsPropose = [
				clientJar.getAbsolutePath(), // must use official jar
				noEnum.getAbsolutePath(),
				output.getAbsolutePath()
		]

		new CommandProposeFieldNames().run(argsPropose)
	}
}

task mapNamedJar(dependsOn: [buildTinyWithEnum, mapIntermediaryJar]) {
	group = mapJarGroup
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file(namedJar)

	//Force the task to always run
	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":mapping minecraft to named")

		mapJar(namedJar, intermediaryJar, buildTinyWithEnum.output, libraries, "intermediary", "named")
	}
}

task insertAutoGeneratedEnumMappings(dependsOn : [buildYarnTiny,mapIntermediaryJar], type : FileOutput){
	group = buildMappingGroup
	def noEnumV2 = buildYarnTiny.v2Output
	output = new File(tempDir, "unmerged-named-v2-with-enum.tiny")

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":seeking auto-mappable fields for unmerged mappings")

		MappingNameCompleter.completeNames(
				intermediaryJar.toPath(),
				noEnumV2.toPath(),
				downloadIntermediary.dest.toPath(),
				output.toPath()
		)
	}
}

task v2UnmergedYarnJar(dependsOn: insertAutoGeneratedEnumMappings, type: Jar) {
	def mappings = insertAutoGeneratedEnumMappings.output
	group = "mapping build"
	outputs.upToDateWhen { false }
	archiveFileName = "yarn-${yarnVersion}-v2.jar"

	from(file(mappings)) {
		rename mappings.name, "mappings/mappings.tiny"
	}
	destinationDirectory.set(file("build/libs"))
}

task generateObfToNamedTiny(type: GenerateObfToNamedTiny, dependsOn: [downloadIntermediary, insertAutoGeneratedEnumMappings]) {
	group = buildMappingGroup
	fallbackNamespace = 'official'
	intermediary = downloadIntermediary.dest
	mappings = insertAutoGeneratedEnumMappings.output
	output = new File(buildDir, "libs/obfToNamed.tiny")
	outputs.upToDateWhen { false }
}

task obfToNamedTinyJar(type: MappingsJar, dependsOn: [generateObfToNamedTiny]) {
	archiveBaseName = 'obfToNamed'
	mappings generateObfToNamedTiny.output
}

task generateObfToNamedITiny(type: GenerateObfToNamedTiny, dependsOn: [downloadIntermediary, insertAutoGeneratedEnumMappings]) {
	group = buildMappingGroup
	fallbackNamespace = 'intermediary'
	intermediary = downloadIntermediary.dest
	mappings = insertAutoGeneratedEnumMappings.output
	output = new File(buildDir, "libs/obfToNamedI.tiny")
	outputs.upToDateWhen { false }
}

task obfToNamedITinyJar(type: MappingsJar, dependsOn: [generateObfToNamedITiny]) {
	archiveBaseName = 'obfToNamedI'
	mappings generateObfToNamedITiny.output
}

task prepareRelease(dependsOn: [obfToNamedTinyJar, obfToNamedITinyJar]) {
	doLast {
		def env = System.getenv()
		def runNumber = env.GITHUB_RUN_NUMBER.toInteger() + 15
		def version = "$minecraft_version-$runNumber"
		def title = "Build $runNumber for $minecraft_version ($version)"
		println "::set-output name=version::$version"
		println "::set-output name=title::$title"
	}
}

void mapJar(File output, File input, File mappings, File libraries, String from, String to) {
	if (output.exists()) {
		output.delete()
	}

	def remapper = TinyRemapper.newRemapper()
			.withMappings(TinyUtils.createTinyMappingProvider(mappings.toPath(), from, to))
			.renameInvalidLocals(true)
			.rebuildSourceFilenames(true)
			.build()

	try {
		def outputConsumer = new OutputConsumerPath.Builder(output.toPath()).build()
		outputConsumer.addNonClassFiles(input.toPath())
		remapper.readInputs(input.toPath())

		libraries.eachFileRecurse(FileType.FILES) { file ->
			remapper.readClassPath(file.toPath())
		}
		remapper.apply(outputConsumer)
		outputConsumer.close()
		remapper.finish()
	} catch (Exception e) {
		remapper.finish()
		throw new RuntimeException("Failed to remap jar", e)
	}
}

class FileOutput extends DefaultTask {
	@OutputFile
	File output
}

class WithV2FileOutput extends DefaultTask {
	@OutputFile
	File v1Output
	@OutputFile
	File v2Output
}

/**
 * Creates a mapping file that drops the {@code intermediary} namespace
 * and fills it with {@code official} names and fills missing {@code named}
 * names with one of the other namespaces.
 */
class GenerateObfToNamedTiny extends DefaultTask {
	@Input
	String fallbackNamespace

	@InputFile
	File intermediary

	@InputFile
	File mappings

	@OutputFile
	File output

	@TaskAction
	def run() {
		def mappingTree = new MemoryMappingTree()
		MappingReader.read(intermediary.toPath(), mappingTree)
		MappingReader.read(mappings.toPath(), mappingTree)

		if (fallbackNamespace != 'intermediary') {
			// Delete all intermediary names
			def removeIntermediary = { entry ->
				def name = entry.getDstName(1)
				if (name && name =~ /^(.+\/class|method|field)_[0-9]+$/) {
					entry.setDstName(entry.srcName, 1)
				}
			}
			for (def clazz : mappingTree.classes) {
				removeIntermediary(clazz)
				for (def method : clazz.methods) {
					removeIntermediary(method)
				}
				for (def field : clazz.fields) {
					removeIntermediary(field)
				}
			}
		}

		output.withWriter {
			def tinyWriter = new Tiny2Writer(it, false)
			def intermediaryCompleter = new MappingNsCompleter(tinyWriter, ['intermediary': 'official'])
			def intermediaryAdder = new MappingDstNsReorder(intermediaryCompleter, 'intermediary', 'named')
			def intermediaryRemover = new MappingDstNsReorder(intermediaryAdder, 'named')
			def namedCompleter = new MappingNsCompleter(intermediaryRemover, [named: fallbackNamespace])
			mappingTree.accept(namedCompleter)
		}
	}
}

class MappingsJar extends Jar {
	def mappings(Object file) {
		from(file) {
			into 'mappings'
			rename { 'mappings.tiny' }
		}
	}
}