build.gradle

buildscript {
	dependencies {
		classpath 'org.kohsuke:github-api:1.135'
		classpath 'org.apache.groovy:groovy-toml:4.0.12'
	}
}

plugins {
	id "java-library"
	id "eclipse"
	id "idea"
	id "maven-publish"
	id 'jacoco'
	id "dev.architectury.loom" version "1.2-SNAPSHOT" apply false
	id "com.diffplug.spotless" version "6.18.0"
	id "org.ajoberstar.grgit" version "3.1.0"
	id "com.matthewprenger.cursegradle" version "1.4.0"
	id "com.modrinth.minotaur" version "2.4.3"
	id "me.modmuss50.remotesign" version "0.4.0" apply false
}

def ENV = System.getenv()
def signingEnabled = ENV.SIGNING_SERVER

version = project.version + "+" + (ENV.GITHUB_RUN_NUMBER ? "" : "local-") + getBranch()
logger.lifecycle("Building Fabric: " + version)


import net.fabricmc.loom.util.gradle.SourceSetHelper
import groovy.json.JsonSlurper
import org.apache.commons.codec.digest.DigestUtils

def getSubprojectVersion(project) {
	// Get the version from the gradle.properties file
	def version = project.properties["${project.name}-version"]

	if (!version) {
		throw new NullPointerException("Could not find version for " + project.name)
	}

	if (grgit == null) {
		return version + "+nogit"
	}

	def latestCommits = grgit.log(paths: [project.name], maxCommits: 1)

	if (latestCommits.isEmpty()) {
		return version + "+uncommited"
	}

	return version + "+" + latestCommits.get(0).id.substring(0, 8) + DigestUtils.sha256Hex(project.rootProject.minecraft_version).substring(0, 2)
}

def getBranch() {
	def ENV = System.getenv()
	if (ENV.GITHUB_REF) {
		def branch = ENV.GITHUB_REF
		return branch.substring(branch.lastIndexOf("/") + 1)
	}

	if (grgit == null) {
		return "unknown"
	}

	def branch = grgit.branch.current().name
	return branch.substring(branch.lastIndexOf("/") + 1)
}

def moduleDependencies(project, List<String> depNames) {
	def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'namedElements') }
	def clientOutputs = /*depNames.iterator().collect { findProject(":$it").sourceSets.client.output }*/ []

	project.dependencies {
		deps.each {
			api it
		}

		clientOutputs.each {
			clientImplementation it
		}
	}

	// As we manually handle the maven artifacts, we need to also manually specify the deps.
	project.publishing {
		publications {
			mavenJava(MavenPublication) {
				pom.withXml {
					def depsNode = asNode().appendNode("dependencies")
					deps.each {
						def depNode = depsNode.appendNode("dependency")
						depNode.appendNode("groupId", it.group)
						depNode.appendNode("artifactId", it.name)
						depNode.appendNode("version", it.version)
						depNode.appendNode("scope", "compile")
					}
				}
			}
		}
	}
}

def testDependencies(project, List<String> depNames) {
	def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'namedElements') }
	def clientOutputs = /*depNames.iterator().collect { findProject(":$it").sourceSets.client.output }*/ []

	project.dependencies {
		deps.each {
			testmodImplementation it
		}

		clientOutputs.each {
			testmodImplementation it
		}
	}
}

allprojects {
	group = "net.fabricmc.fabric-api"

	apply plugin: "maven-publish"
	apply plugin: "me.modmuss50.remotesign"

	tasks.withType(GenerateModuleMetadata) {
		enabled = false
	}

	if (signingEnabled) {
		remoteSign {
			requestUrl = ENV.SIGNING_SERVER
			pgpAuthKey = ENV.SIGNING_PGP_KEY
			jarAuthKey = ENV.SIGNING_JAR_KEY

			afterEvaluate {
				// PGP sign all maven publications.
				sign publishing.publications.mavenJava
			}
		}
	}

	publishing {
		setupRepositories(repositories)
	}

	if (it.name == "deprecated") {
		return
	}

	apply plugin: "java-library"
	apply plugin: "checkstyle"
	apply plugin: "dev.architectury.loom"
	apply plugin: "com.diffplug.spotless"

	tasks.withType(JavaCompile).configureEach {
		it.options.release = 17
	}

	java {
		// Must be added before the split source sets are setup.
		withSourcesJar()
	}

	loom {
//		splitEnvironmentSourceSets()
	}

	sourceSets {
		main {
			java {
				srcDir "src/client/java"
			}
			resources {
				srcDir "src/client/resources"
			}
		}
		
		testmod {
			compileClasspath += main.compileClasspath
			runtimeClasspath += main.runtimeClasspath

			java {
				srcDir "src/testmodClient/java"
			}
			resources {
				srcDir "src/testmodClient/resources"
			}
		}

		test {
			compileClasspath += testmod.compileClasspath
			runtimeClasspath += testmod.runtimeClasspath
		}
	}

	loom {
		runtimeOnlyLog4j = true

		forge {
			convertAccessWideners = true
		}

		runs {
			configureEach {
				property "coremod.yarn", "true"
				// (ugly) workaround for https://github.com/MinecraftForge/CoreMods/issues/31
				property "true", "true"

				property "mixin.debug", "true"
			}
			
			testmodClient {
				client()
				ideConfigGenerated project.rootProject == project
				name = "Testmod Client"
				source sourceSets.testmod
			}
			testmodServer {
				server()
				ideConfigGenerated project.rootProject == project
				name = "Testmod Server"
				source sourceSets.testmod
			}
		}
	}
	
	configureLaunch {
		dependsOn(configurations.testmodRuntimeClasspath/*, configurations.testmodClientRuntimeClasspath*/)
	}

	allprojects.each { p ->
		if (project.name == "deprecated") {
			return
		}

		loom.mods.register(p.name) {
			sourceSet p.sourceSets.main
//			sourceSet p.sourceSets.client
		}

		loom.mods.register(p.name + "-testmod") {
			sourceSet p.sourceSets.testmod
//			sourceSet p.sourceSets.testmodClient
		}
	}

	dependencies {
		minecraft "com.mojang:minecraft:$rootProject.minecraft_version"
		mappings "net.fabricmc:yarn:${rootProject.minecraft_version}${project.yarn_version}:v2"
		forge "net.minecraftforge:forge:${rootProject.forge_version}"
		modApi "net.fabricmc:fabric-loader:${project.loader_version}"

		testmodImplementation sourceSets.main.output
//		testmodClientImplementation sourceSets.main.output
//		testmodClientImplementation sourceSets.client.output
//		testmodClientImplementation sourceSets.testmod.output

		testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
		testImplementation sourceSets.testmod.output
	}

	test {
		useJUnitPlatform()

		afterEvaluate {
			// See: https://github.com/FabricMC/fabric-loader/pull/585
			def classPathGroups = loom.mods.stream()
					.map { modSettings ->
						SourceSetHelper.getClasspath(modSettings, getProject()).stream()
								.map(File.&getAbsolutePath)
								.collect(Collectors.joining(File.pathSeparator))
					}
					.collect(Collectors.joining(File.pathSeparator+File.pathSeparator))

			systemProperty("fabric.classPathGroups", classPathGroups)
		}
	}

	tasks.withType(ProcessResources).configureEach {
		exclude "fabric.mod.json"
	}
	tasks.withType(Jar).configureEach {
		manifest {
			attributes(["Implementation-Version" : project.version])
		}
	}

	spotless {
		java {
			licenseHeaderFile(rootProject.file("HEADER"))
		}
	}

	checkstyle {
		configFile = rootProject.file("checkstyle.xml")
		toolVersion = "10.11.0"
	}

	tasks.withType(AbstractArchiveTask).configureEach {
		preserveFileTimestamps = false
		reproducibleFileOrder = true
	}

	if (signingEnabled) {
		remoteSign {
			sign remapJar
		}
	}

	// Run this task after updating minecraft to regenerate any required resources
	tasks.register('generateResources') {
		group = "fabric"
	}

	tasks.register('testmodJar', Jar) {
		from sourceSets.testmod.output
//		from sourceSets.testmodClient.output
		destinationDirectory = new File(project.buildDir, "devlibs")
		archiveClassifier = "testmod"
	}

	[jar, sourcesJar].each {
		it.from(rootProject.file("LICENSE")) {
			rename { "${it}-${project.base.archivesName.get()}"}
		}
	}

	if (file("src/client").exists() && !file("src/main").exists()) {
		remapJar {
			additionalClientOnlyEntries.add("LICENSE-${project.base.archivesName.get()}")
		}

		remapSourcesJar {
			additionalClientOnlyEntries.add("LICENSE-${project.base.archivesName.get()}")
		}
	}

	tasks.register('remapTestmodJar', net.fabricmc.loom.task.RemapJarTask) {
		dependsOn testmodJar
		input = testmodJar.archiveFile
		archiveClassifier = "testmod"
		addNestedDependencies = false
		includesClientOnlyClasses = true
//		clientOnlySourceSetName = sourceSets.testmodClient.name
	}
	build.dependsOn remapTestmodJar

	tasks.register('validateMixinNames', net.fabricmc.loom.task.ValidateMixinNameTask) {
		source(sourceSets.main.output)
//		source(sourceSets.client.output)
		source(sourceSets.testmod.output)
	}

	// Apply to each valid subproject.
	apply from: rootProject.file('gradle/package-info.gradle')
	apply from: rootProject.file('gradle/validate-annotations.gradle')
}

remapTestmodJar {
	def testModJarTasks = []

	subprojects {
		if (it.name == "deprecated" || !(it.file("src/testmod").exists() || it.file("src/testmodClient").exists())) {
			return
		}

		testModJarTasks += it.tasks.remapTestmodJar
	}

	nestedJars.setFrom(testModJarTasks)
	addNestedDependencies = true
//	clientOnlySourceSetName = sourceSets.testmodClient.name
}

// Apply auxiliary buildscripts to submodules
// This must be done after all plugins are applied to subprojects
apply from: "gradle/module-validation.gradle"
apply from: "gradle/module-versioning.gradle"

loom {
	// Required as the item-group API uses access widened classes in its API, without this the javadoc generation fails.
//	accessWidenerPath = file("fabric-item-group-api-v1/src/main/resources/fabric-item-group-api-v1.accesswidener")
}

javadoc {
	options {
		source = "17"
		encoding = "UTF-8"
		charSet = "UTF-8"
		memberLevel = JavadocMemberLevel.PACKAGE
		links(
				"https://maven.fabricmc.net/docs/yarn-${rootProject.minecraft_version}${project.yarn_version}/"
				)
		// Disable the crazy super-strict doclint tool in Java 8
		addStringOption("Xdoclint:none", "-quiet")

		tags(
				'apiNote:a:API Note:',
				'implSpec:a:Implementation Requirements:',
				'implNote:a:Implementation Note:'
				)
	}

	allprojects.each {
		if (it.name == "deprecated") {
			return
		}

		source(it.sourceSets.main.allJava)
//		source(it.sourceSets.client.allJava)
	}

	classpath = files(sourceSets.main.compileClasspath/*, sourceSets.client.compileClasspath*/)
	include("**/api/**")
	failOnError true
}

tasks.register('javadocJar', Jar) {
	dependsOn javadoc
	from javadoc.destinationDir
	//Set as `fatjavadoc` to prevent an ide form trying to use this javadoc, over using the modules javadoc
	archiveClassifier = "fatjavadoc"
}

build.dependsOn javadocJar

loom {
	runs {
		gametest {
			inherit testmodServer

			name "Game Test"

			// Enable the gametest runner
			vmArg "-Dfabric-api.gametest"
			vmArg "-Dfabric-api.gametest.report-file=${project.buildDir}/junit.xml"
			runDir "build/gametest"
		}
		autoTestServer {
			inherit testmodServer
			name "Auto Test Server"
			vmArg "-Dfabric.autoTest"
		}
		autoTestClient {
			inherit testmodClient
			name "Auto Test Client"
			vmArg "-Dfabric.autoTest"
		}

		// Create duplicate tasks for this, as jacoco slows things down a bit
		gametestCoverage {
			inherit gametest
			name "Game Test Coverage"
			ideConfigGenerated = false
		}

		autoTestClientCoverage {
			inherit autoTestClient
			name "Auto Test Client Coverage"
			ideConfigGenerated = false
		}
	}
}
test.dependsOn runGametest

def coverageTasks = [
	runGametestCoverage,
	runAutoTestClientCoverage
]

jacoco {
	coverageTasks.forEach {
		applyTo it
	}
}

tasks.register('coverage', JacocoReport) {
	dependsOn coverageTasks
	coverageTasks.forEach {
		executionData it
	}

	// Add all source as input
	allprojects { p ->
		if (p.path.startsWith(":deprecated")) {
			return
		}
		sourceSets p.sourceSets.main, p.sourceSets.client, p.sourceSets.testmod/*, p.sourceSets.testmodClient*/
	}

	// Exclude mixins
	classDirectories.setFrom(files(classDirectories.files.collect {
		fileTree(dir: it, exclude: '**/mixin/**')
	}))
}

configurations {
	productionRuntime {
		extendsFrom configurations.minecraftLibraries
		extendsFrom configurations.loaderLibraries
		extendsFrom configurations.minecraftRuntimeLibraries
	}
	productionRuntimeServer
}

dependencies {
	productionRuntime "net.fabricmc:fabric-loader:${project.loader_version}"
	productionRuntime "net.fabricmc:intermediary:${project.minecraft_version}"

	productionRuntimeServer "net.fabricmc:fabric-installer:${project.installer_version}:server"
}

import net.fabricmc.loom.util.Platform

// This is very far beyond loom's API if you copy this, you're on your own.
tasks.register('runProductionAutoTestClient', JavaExec) {
	dependsOn remapJar, remapTestmodJar, downloadAssets
	classpath.from configurations.productionRuntime
	mainClass = "net.fabricmc.loader.impl.launch.knot.KnotClient"
	workingDir = file("run")

	doFirst {
		classpath.from loom.minecraftProvider.minecraftClientJar
		workingDir.mkdirs()

		args(
				"--assetIndex", loom.minecraftProvider.versionInfo.assetIndex().fabricId(loom.minecraftProvider.minecraftVersion()),
				"--assetsDir", new File(loom.files.userCache, "assets").absolutePath,
				"--gameDir", workingDir.absolutePath
				)

		if (Platform.CURRENT.operatingSystem.isMacOS()) {
			jvmArgs(
					"-XstartOnFirstThread"
					)
		}

		jvmArgs(
				"-Dfabric.addMods=${remapJar.archiveFile.get().asFile.absolutePath}${File.pathSeparator}${remapTestmodJar.archiveFile.get().asFile.absolutePath}",
				"-Dfabric.autoTest"
				)
	}
}

tasks.register('serverPropertiesJar', Jar) {
	def propsFile = file("build/tmp/install.properties")

	doFirst {
		propsFile.text = """\
						fabric-loader-version=${project.loader_version}
						game-version=${project.minecraft_version}
						""".stripMargin().stripIndent()
	}

	archiveFileName = "test-server-properties.jar"
	destinationDirectory = file("build/tmp")
	from(propsFile)
}

tasks.register('runProductionAutoTestServer', JavaExec) {
	dependsOn remapJar, remapTestmodJar, serverPropertiesJar
	classpath.from configurations.productionRuntimeServer, serverPropertiesJar
	mainClass = "net.fabricmc.installer.ServerLauncher"
	workingDir = file("run")

	doFirst {
		workingDir.mkdirs()

		jvmArgs(
				"-Dfabric.addMods=${remapJar.archiveFile.get().asFile.absolutePath}${File.pathSeparator}${remapTestmodJar.archiveFile.get().asFile.absolutePath}",
				"-Dfabric.autoTest"
				)

		args("nogui")
	}
}

// Format all the gradle files
spotless {
	groovyGradle {
		target 'src/**/*.gradle', '*.gradle', 'gradle/*.gradle'
		greclipse()
	}
}

def addPomMetadataInformation(Project project, MavenPom pom) {
	def modJsonFile = project.file("src/main/resources/fabric.mod.json")

	if (!modJsonFile.exists()) {
		modJsonFile = project.file("src/client/resources/fabric.mod.json")
	}

	def modJson = new JsonSlurper().parse(modJsonFile)
	pom.name = modJson.name
	pom.url = "https://github.com/FabricMC/fabric/tree/HEAD/${project.rootDir.relativePath(project.projectDir)}"
	pom.description = modJson.description
	pom.licenses {
		license {
			name = "Apache-2.0"
			url = "https://github.com/FabricMC/fabric/blob/HEAD/LICENSE"
		}
	}
	pom.developers {
		developer {
			name = "FabricMC"
			url = "https://fabricmc.net/"
		}
	}
	pom.scm {
		connection = "scm:git:https://github.com/FabricMC/fabric.git"
		url = "https://github.com/FabricMC/fabric"
		developerConnection = "scm:git:git@github.com:FabricMC/fabric.git"
	}
	pom.issueManagement {
		system = "GitHub"
		url = "https://github.com/FabricMC/fabric/issues"
	}
}

subprojects {
	if (it.name == "deprecated") {
		return
	}

	dependencies {
		testmodImplementation sourceSets.main.output

		// Make all modules depend on the gametest api (and thus res loader) to try and promote its usage.
		if (project.name != "fabric-gametest-api-v1") {
//			testmodImplementation project(path: ':fabric-gametest-api-v1', configuration: 'namedElements')
//			testmodClientImplementation project(":fabric-gametest-api-v1").sourceSets.client.output
//			testmodImplementation project(path: ':fabric-resource-loader-v0', configuration: 'namedElements')
//			testmodClientImplementation project(":fabric-resource-loader-v0").sourceSets.client.output
		}

		// Make all testmods run with registry-sync-v0 as it is required to register new objects.
		if (project.name != "fabric-registry-sync-v0") {
//			testmodRuntimeOnly project(path: ':fabric-registry-sync-v0', configuration: 'namedElements')
//			testmodClientImplementation project(":fabric-registry-sync-v0").sourceSets.client.output
		}
	}

	publishing {
		publications {
			mavenJava(MavenPublication) {
				pom {
					addPomMetadataInformation(project, pom)
				}
				artifact(signingEnabled ? signRemapJar.output : remapJar) {
					builtBy(signingEnabled ? signRemapJar : remapJar)
				}

				artifact(remapSourcesJar) {
					builtBy remapSourcesJar
				}
			}
		}
	}

	// We manually handle the pom generation
	loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)

	javadoc.enabled = false
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			artifact(signingEnabled ? signRemapJar.output : remapJar) {
				builtBy(signingEnabled ? signRemapJar : remapJar)
			}

			artifact(sourcesJar) {
				builtBy remapSourcesJar
			}

			artifact javadocJar
			artifact remapTestmodJar

			pom {
				addPomMetadataInformation(rootProject, pom)
			}

			pom.withXml {
				def depsNode = asNode().appendNode("dependencies")
				subprojects.each {
					// Dont depend on the deprecated modules in the main artifact.
					if (it.path.startsWith(":deprecated")) {
						return
					}

					def depNode = depsNode.appendNode("dependency")
					depNode.appendNode("groupId", it.group)
					depNode.appendNode("artifactId", it.name)
					depNode.appendNode("version", it.version)
					depNode.appendNode("scope", "compile")
				}
			}
		}
	}
}

// Required until the deprecation is removed. Fabric API's main jar that is published to maven does not contain sub modules.
loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)

void setupRepositories(RepositoryHandler repositories) {
	//repositories.mavenLocal() // uncomment for testing
	def ENV = System.getenv()
	if (ENV.MAVEN_URL) {
		repositories.maven {
			url ENV.MAVEN_URL
			if (ENV.MAVEN_USERNAME) {
				credentials {
					username ENV.MAVEN_USERNAME
					password ENV.MAVEN_PASSWORD
				}
			}
		}
	}
}

subprojects.each {
	if (it.name == "deprecated") {
		return
	}

	remapJar.dependsOn("${it.path}:remapJar")
}

// These modules are not included in the fat jar, maven will resolve them via the pom.
def devOnlyModules = ["fabric-gametest-api-v1",]

dependencies {
	afterEvaluate {
		subprojects.each {
			if (it.name == "deprecated") {
				return
			}

			api project(path: "${it.path}", configuration: "namedElements")
//			clientImplementation project("${it.path}:").sourceSets.client.output

			testmodImplementation project("${it.path}:").sourceSets.testmod.output
//			testmodClientImplementation project("${it.path}:").sourceSets.testmodClient.output
		}
	}
}

remapJar {
	afterEvaluate {
		subprojects.each {
			if (it.name in devOnlyModules || it.name == "deprecated") {
				return
			}

			// Include the signed or none signed jar from the sub project.
			nestedJars.from project("${it.path}").tasks.getByName(signingEnabled ? "signRemapJar" : "remapJar")
		}
	}
}

curseforge {
	if (ENV.CURSEFORGE_API_KEY) {
		apiKey = ENV.CURSEFORGE_API_KEY
	}

	project {
		id = "306612"
		changelog = ENV.CHANGELOG ?: "No changelog provided"
		releaseType = project.prerelease == "true" ? "beta" : "release"
		addGameVersion "1.20.1"
		addGameVersion "Fabric"

		mainArtifact(signingEnabled ? signRemapJar.output : remapJar) {
			displayName = "[$project.minecraft_version] Fabric API $project.version"
		}

		afterEvaluate {
			uploadTask.dependsOn("remapJar")
		}
	}

	options {
		forgeGradleIntegration = false
	}
}

if (signingEnabled) {
	project.tasks.curseforge.dependsOn signRemapJar
	project.tasks.modrinth.dependsOn signRemapJar
	build.dependsOn signRemapJar
}

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

import java.util.stream.Collectors

tasks.register('github') {
	dependsOn(signingEnabled ? signRemapJar : remapJar)
	onlyIf {
		ENV.GITHUB_TOKEN
	}

	doLast {
		def github = GitHub.connectUsingOAuth(ENV.GITHUB_TOKEN as String)
		def repository = github.getRepository(ENV.GITHUB_REPOSITORY)

		def releaseBuilder = new GHReleaseBuilder(repository, version as String)
		releaseBuilder.name("[$project.minecraft_version] Fabric API $project.version")
		releaseBuilder.body(ENV.CHANGELOG ?: "No changelog provided")
		releaseBuilder.commitish(getBranch())
		releaseBuilder.prerelease(project.prerelease == "true")

		def ghRelease = releaseBuilder.create()
		ghRelease.uploadAsset(signingEnabled ? signRemapJar.output.get().getAsFile() : remapJar.archiveFile.get().getAsFile(), "application/java-archive");
	}
}

modrinth {
	projectId = "fabric-api"
	versionName = "[$project.minecraft_version] Fabric API $project.version"
	versionType = project.prerelease == "true" ? "beta" : "release"
	changelog = ENV.CHANGELOG ?: "No changelog provided"

	uploadFile = signingEnabled ? signRemapJar.output : remapJar
}

// A task to ensure that the version being released has not already been released.
tasks.register('checkVersion') {
	doFirst {
		def xml = new URL("https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api/maven-metadata.xml").text
		def metadata = new XmlSlurper().parseText(xml)
		def versions = metadata.versioning.versions.version*.text();
		if (versions.contains(version)) {
			throw new RuntimeException("${version} has already been released!")
		}
	}
}

github.mustRunAfter checkVersion
project.tasks.modrinth.mustRunAfter checkVersion
publish.mustRunAfter checkVersion
project.tasks.curseforge.mustRunAfter checkVersion

import groovy.json.JsonBuilder
import groovy.json.JsonSlurper
import groovy.toml.TomlBuilder
import java.nio.file.Files
import java.nio.charset.StandardCharsets
import net.fabricmc.loom.util.aw2at.Aw2At
import net.fabricmc.loom.util.LfWriter
import net.fabricmc.lorenztiny.TinyMappingsReader
import net.fabricmc.loom.util.service.UnsafeWorkQueueHelper
import net.fabricmc.loom.task.service.MappingsService
import javax.inject.Inject
import net.fabricmc.loom.util.service.BuildSharedServiceManager
import org.gradle.build.event.BuildEventsListenerRegistry
import net.fabricmc.loom.api.mappings.layered.MappingsNamespace
import net.fabricmc.loom.util.FileSystemUtil

import org.cadixdev.at.AccessTransformSet
import org.cadixdev.at.io.AccessTransformFormats
import org.cadixdev.lorenz.MappingSet

allprojects {
	for (def sourceSet in [
		sourceSets.main,
	//	sourceSets.client,
		sourceSets.testmod
	]) {
		// We have to capture the source set name for the lazy string literals,
		// otherwise it'll just be whatever the last source set is in the list.
		def sourceSetName = sourceSet.name
		def resourceRoots = sourceSet.resources.srcDirs
		def taskName = sourceSet.getTaskName('generate', 'ForgeModMetadata')
		def task = tasks.register(taskName, GenerateForgeModMetadata) {
			group = 'fabric'
			description = "Generates mods.toml files for $sourceSetName fabric mod."
	
			// Only apply to default source directory since we also add the generated
			// sources to the source set.
			sourceRoots.from(resourceRoots)
			outputDir = file("src/generated/$sourceSetName/resources")
			loaderVersionString = rootProject.forge_version.tokenize('-')[1].tokenize('.')[0]
			minecraftVersionString = rootProject.minecraft_version
			dataPackFormat = rootProject.server_data_pack_format.toInteger()
			packFormat = rootProject.pack_format.toInteger()
			addMixinConfigs = sourceSet.name.startsWith("test")
			accessWidener = loom.accessWidenerPath
		}
		sourceSet.resources.srcDir task
	
		if (!sourceSet.name.startsWith("test")) {
			for (def sourceRoot in resourceRoots) {
				if (!sourceRoot.isDirectory()) {
					continue
				}
				def fabricMetadata = sourceRoot.toPath().resolve("fabric.mod.json").toFile()
				if (fabricMetadata.exists()) {
					def parser = new JsonSlurper()
					def json = parser.parse(fabricMetadata)
					if (json.mixins) {
						for (def mixin in json.mixins) {
							if (mixin instanceof Map) {
								loom.forge.mixinConfig mixin.config
							} else if (mixin instanceof String) {
								loom.forge.mixinConfig mixin
							} else {
								throw new RuntimeException("Unknown mixin config type ${mixin.getClass()}")
							}
						}
					}
				}
			}
		}
	
		def cleanTask = tasks.register(sourceSet.getTaskName('clean', 'ForgeModMetadata'), Delete) {
			group = 'fabric'
			delete file("src/generated/$sourceSetName/resources")
		}
		clean.dependsOn cleanTask
	}
	
	def localDevJar = tasks.register("localDevJar", Jar) {
		dependsOn jar
		from(zipTree(jar.archiveFile))
		rename "accesstransformer_dev.cfg", "accesstransformer.cfg"
		archiveClassifier = "local"
		destinationDirectory = new File(project.buildDir, "devlibs")
		manifest.from(jar.manifest)
	}
	remapJar {
		doLast {
			try (FileSystemUtil.Delegate fileSystem = FileSystemUtil.getJarFileSystem(archiveFile.get().asFile.toPath(), false)) {
				def fs = fileSystem.get()
				def atPath = fs.getPath("META-INF/accesstransformer_dev.cfg")
				Files.deleteIfExists(atPath)
			}
		}
	}
	afterEvaluate {
		configurations.namedElements {
			outgoing.artifacts.clear()
			outgoing.artifact(localDevJar)
		}
	}
}

subprojects {
	loom {
		runs {
			gametest {
				server()
				ideConfigGenerated project.rootProject == project
				name = "Testmod Game Test Server"
				source sourceSets.testmod

				// Enable the gametest runner
				property "forge.gameTestServer", "true"
			}
		}
	}
}

abstract class GenerateForgeModMetadata extends DefaultTask {
	@SkipWhenEmpty
	@InputFiles
	final ConfigurableFileCollection sourceRoots = project.objects.fileCollection()

	@OutputDirectory
	final DirectoryProperty outputDir = project.objects.directoryProperty()

	@Input
	final Property<String> loaderVersionString = project.objects.property(String)

	@Input
	final Property<String> minecraftVersionString = project.objects.property(String)

	@Input
	final Property<Integer> dataPackFormat = project.objects.property(Integer)

	@Input
	final Property<Integer> packFormat = project.objects.property(Integer)

	@Input
	final Property<Boolean> addMixinConfigs = project.objects.property(Boolean)

	@InputFile
	@Optional
	final RegularFileProperty accessWidener = project.objects.fileProperty()

	@Inject
	protected abstract BuildEventsListenerRegistry getBuildEventsListenerRegistry()

	private final Property<String> mappingServiceUuid = project.objects.property(String)

	@Inject
	public GenerateForgeModMetadata() {
		Provider<BuildSharedServiceManager> serviceManagerProvider = BuildSharedServiceManager.createForTask(this, getBuildEventsListenerRegistry())

		mappingServiceUuid.value(project.provider { UnsafeWorkQueueHelper.create(MappingsService.createDefault(project, serviceManagerProvider.get().get(), MappingsNamespace.NAMED.toString(), MappingsNamespace.NAMED.toString())) })
	}

	def normalizeModid(String modid) {
		return modid.replaceAll('-', '_')
	}

	@TaskAction
	def run() {
		def output = outputDir.get().asFile.toPath()
		output.deleteDir()
		for (def sourceRoot in sourceRoots) {
			if (!sourceRoot.isDirectory()) {
				continue
			}

			def root = sourceRoot.toPath()
			def fabricMetadata = root.resolve("fabric.mod.json")

			if (Files.notExists(fabricMetadata)) {
				continue
			}

			def parser = new JsonSlurper()
			def json = parser.parse(fabricMetadata)
			def toml = new TomlBuilder()
			def nextMajor = (minecraftVersionString.get().tokenize('.')[1].toInteger()) + 1
			def excludedDeps = ["fabricloader", "java", "minecraft"]
			def modDependencies = json.depends.findAll { !excludedDeps.contains(it.key) }.collect {
				def normalModid = normalizeModid(it.key as String)
				return { _ ->
					modId normalModid
					mandatory true
					versionRange "[0, )"
					ordering "NONE"
					side "BOTH"
				}
			}
			def normalModid = normalizeModid(json.id)
			toml {
				modLoader "javafml"
				loaderVersion "[${loaderVersionString.get()},)"
				license json.license ?: "All Rights Reserved"
				if (json.environment == "client") {
					displayTest "IGNORE_SERVER_VERSION"
				}

				mods([
					{
						modId normalModid
						version '${file.jarVersion}'
						displayName json.name
						if (json.icon) {
							logoFile json.icon
						}
						if (json.authors) {
							authors json.authors.join(', ')
						}
						if (json.description) {
							description json.description
						}
					}
				])

				dependencies {
					"$normalModid"([
						{
							modId "forge"
							mandatory true
							versionRange "[${loaderVersionString.get()},)"
							ordering "NONE"
							side "BOTH"
						},
						{
							modId "minecraft"
							mandatory true
							versionRange "[${minecraftVersionString.get()},1.$nextMajor)"
							ordering "NONE"
							side "BOTH"
						}
					] + modDependencies)
				}
			}

			def modsToml = output.resolve("META-INF/mods.toml")
			Files.deleteIfExists(modsToml)
			Files.createDirectories(modsToml.parent)
			modsToml.withWriter { toml.writeTo(it) }

			if (addMixinConfigs.get() && json.mixins) {
				def configs = json.mixins.collect {
					if (it instanceof Map) {
						return it.config
					} else if (it instanceof String) {
						return it
					} else {
						throw new RuntimeException("Unknown mixin config type ${it.getClass()}")
					}
				}.join(',')
				def manifest = output.resolve("META-INF/MANIFEST.MF")
				Files.createDirectories(manifest.parent)
				manifest.withPrintWriter {
					it.println("MixinConfigs: $configs")
				}
			}

			def metadataJson = new JsonBuilder()
			metadataJson {
				pack {
					description {
						text "$normalModid resources"
					}
					"forge:server_data_pack_format" dataPackFormat.get()
					pack_format packFormat.get()
				}
			}
			def packMcMeta = output.resolve("pack.mcmeta")
			packMcMeta.withWriter { metadataJson.writeTo(it) }
			
			if (accessWidener.isPresent()) {
				def awPath = accessWidener.get().asFile.toPath()
				def atPath = output.resolve("META-INF/accesstransformer_dev.cfg")
				
				AccessTransformSet at = AccessTransformSet.create()
				try (BufferedReader reader = Files.newBufferedReader(awPath, StandardCharsets.UTF_8)) {
					at.merge(Aw2At.toAccessTransformSet(reader));
				}

				MappingsService service = UnsafeWorkQueueHelper.get(mappingServiceUuid, MappingsService.class);

				try (TinyMappingsReader reader = new TinyMappingsReader(service.getMemoryMappingTree(), service.getFromNamespace(), service.getToNamespace())) {
					MappingSet mappingSet = reader.read();
					at = at.remap(mappingSet);
				}

				try (Writer writer = new LfWriter(Files.newBufferedWriter(atPath))) {
					AccessTransformFormats.FML.write(writer, at);
				}
			}
		}
	}
}