build.gradle

plugins {
	id 'org.quiltmc.loom' version '1.2.+'
	id 'org.quiltmc.gradle.licenser' version '2.0.+'
	id 'java-library'
	id 'maven-publish'
	id 'com.github.johnrengelman.shadow' version '7.1.2'
	id 'com.modrinth.minotaur' version '2.+'
	id 'com.matthewprenger.cursegradle' version '1.4.+'
}

import com.modrinth.minotaur.dependencies.ModDependency

group = project.maven_group
version = "${project.mod_version}+${project.minecraft_version}"
archivesBaseName = project.archives_base_name
Set<String[]> modules = [
		["core", "crash_info"],
		["core", "lifecycle_events"],
		["core", "resource_loader"],
		["block", "block_extensions"],
		["gui", "screen"],
		["gui", "tooltip"]
]
Set<String> fabricModules = [
		'fabric-model-loading-api-v1',
		'fabric-renderer-api-v1',
		'fabric-renderer-indigo'
]
Set<String> runtimeModules = [
		'fabric-lifecycle-events-v1',
		'fabric-key-binding-api-v1',
		'fabric-rendering-v1',
		'fabric-resource-loader-v0',
		'fabric-screen-api-v1'
]

// This field defines the Java version your mod target.
def targetJavaVersion = 17

boolean isMCVersionNonRelease() {
	return project.minecraft_version.matches('^\\d\\dw\\d\\d[a-z]$')
			|| project.minecraft_version.matches('\\d+\\.\\d+-(pre|rc)(\\d+)')
}

String getMCVersionString() {
	if (isMCVersionNonRelease()) {
		return project.minecraft_version
	}
	def version = project.minecraft_version.split('\\.')
	return version[0] + '.' + version[1]
}

String getVersionType() {
	if (isMCVersionNonRelease() || version.contains("-alpha.")) {
		return "alpha"
	} else if (version.contains("-beta.")) {
		return "beta"
	} else {
		return "release"
	}
}

String parseReadme() {
	def linkRegex = /!\[([A-z._ ]+)]\((images\/[A-z.\/_]+)\)/

	def readme = (String) file('README.md').text
	def lines = new ArrayList<>(Arrays.asList(readme.split("\n")))
	def it = lines.iterator()

	boolean shouldRemove = false;
	while (it.hasNext()) {
		def line = it.next();

		if (line.equals("<!-- modrinth_exclude.long_start -->")) {
			shouldRemove = true
		}

		if (shouldRemove) {
			it.remove()
		}

		if (line.equals("<!-- modrinth_exclude.long_end -->")) {
			shouldRemove = false
		}
	}

	readme = lines.join("\n")
	readme = readme.replaceAll(linkRegex, '![$1](https://raw.githubusercontent.com/LambdAurora/LambdaBetterGrass/1.20/$2)')
	return readme
}

String fetchChangelog() {
	def changelogText = file('CHANGELOG.md').text
	def regexVersion = ((String) project.mod_version).replaceAll('\\.', /\\./).replaceAll('\\+', '\\+')
	def changelogRegex = ~"###? ${regexVersion}\\n\\n(( *- .+\\n)+)"
	def matcher = changelogText =~ changelogRegex

	if (matcher.find()) {
		def changelogContent = matcher.group(1)

		def changelogLines = changelogText.split('\n')
		def linkRefRegex = ~'^\\[([A-z\\d _\\-/+.]+)]: '
		for (int i = changelogLines.length - 1; i > 0; i--) {
			def line = changelogLines[i]
			if ((line =~ linkRefRegex).find())
				changelogContent += '\n' + line
			else break
		}
		return changelogContent
	} else {
		return null;
	}
}

repositories {
	mavenLocal()
	mavenCentral()
	maven {
		name 'Gegy'
		url 'https://maven.gegy.dev'
		content {
			includeGroup 'dev.lambdaurora'
		}
	}
	maven {
		name 'TerraformersMC'
		url 'https://maven.terraformersmc.com/'
		content {
			includeGroup 'com.terraformersmc'
		}
	}
}

configurations {
	shadow
	api.extendsFrom shadow
}

loom {
	accessWidenerPath = file("src/main/resources/lambdabettergrass.accesswidener")
}

dependencies {
	minecraft "com.mojang:minecraft:${project.minecraft_version}"
	mappings "org.quiltmc:quilt-mappings:${minecraft_version}+build.${project.quilt_mappings}:intermediary-v2"
	modImplementation "org.quiltmc:quilt-loader:${project.loader_version}"

	modules.stream().map { "org.quiltmc.qsl.${it[0]}:${it[1]}:${project.qsl_version}+${project.minecraft_version}" }
			.forEach {
				modImplementation(it) {
					exclude module: "quilt-loader"
				}
			}
	// Fabric API.
	fabricModules.stream().map { "org.quiltmc.quilted-fabric-api:${it}:${project.fabric_api_version}-${project.minecraft_version}" }
			.forEach {
				modImplementation(it) {
					exclude module: "quilt-loader"
				}
			}
	runtimeModules.stream().map { "org.quiltmc.quilted-fabric-api:${it}:${project.fabric_api_version}-${project.minecraft_version}" }
			.forEach {
				modImplementation(it) {
					exclude module: "quilt-loader"
				}
			}
	modLocalRuntime("org.quiltmc.qsl.entity:entity_events:${project.qsl_version}+${project.minecraft_version}") {
		exclude module: "quilt-loader"
	}

	include modImplementation("dev.lambdaurora:spruceui:${project.spruceui_version}")

	modImplementation("com.terraformersmc:modmenu:${project.modmenu_version}") {
		transitive = false
	}

	shadow 'com.electronwill.night-config:core:3.6.3'
	shadow 'com.electronwill.night-config:toml:3.6.3'
}

java {
	sourceCompatibility = JavaVersion.toVersion(targetJavaVersion)
	targetCompatibility = JavaVersion.toVersion(targetJavaVersion)

	withSourcesJar()
}

tasks.withType(JavaCompile).configureEach {
	it.options.encoding = 'UTF-8'
	it.options.deprecation(true)
	it.options.incremental(true)
	it.options.release.set(targetJavaVersion)
}

processResources {
	inputs.property 'version', project.version

	filesMatching('fabric.mod.json') {
		expand 'version': project.version
	}
	filesMatching('quilt.mod.json') {
		expand 'version': project.version
	}
}

jar {
	from('LICENSE') {
		rename { "${it}_${project.archivesBaseName}" }
	}
}

license {
	rule file('HEADER')
	include '**/*.java'
}

shadowJar {
	dependsOn jar
	configurations = [project.configurations.shadow]
	destinationDirectory.set(file("${project.buildDir}/devlibs"))
	archiveClassifier.set('dev')

	relocate 'com.electronwill.nightconfig', 'dev.lambdaurora.lambdabettergrass.shadow.nightconfig'
}
remapJar.dependsOn(shadowJar)

modrinth {
	projectId = project.modrinth_id
	versionName = "LambdaBetterGrass ${project.mod_version} (${getMCVersionString()})"
	gameVersions = [project.minecraft_version]
	versionType = isMCVersionNonRelease() ? "beta" : "release"
	loaders = ["quilt"]
	uploadFile = tasks.remapJar
	dependencies = [
			new ModDependency("qvIfYCYJ", "required")
	]
	syncBodyFrom = parseReadme()

	// Changelog fetching
	def changelogContent = fetchChangelog()

	if (changelogContent) {
		changelog = changelogContent
	} else {
		afterEvaluate {
			tasks.modrinth.setEnabled(false)
		}
	}

	// If we don't have a MODRINTH_TOKEN, don't run the modrinth publish tasks.
	if (!System.getenv("MODRINTH_TOKEN")) {
        project.logger.debug('MODRINTH_TOKEN is not set! Disabled modrinth and modrinthSyncBody tasks.')
		tasks.modrinth.setEnabled(false)
		tasks.modrinthSyncBody.setEnabled(false)
	}
}

curseforge {
	if (System.getenv("CURSEFORGE_TOKEN")) {
		apiKey = System.getenv("CURSEFORGE_TOKEN")
	} else { // If we don't have a CURSEFORGE_TOKEN, don't run the curseforge publish tasks.
        project.logger.debug('CURSEFORGE_TOKEN is not set! Disabled curseforge task.')
		tasks.curseforge.setEnabled(false)
	}

	project {
		id = project.curseforge_id
		releaseType = this.getVersionType()
		addGameVersion project.minecraft_version
		addGameVersion "Quilt"
		addGameVersion "Java 17"
		addGameVersion "Java 18"

		// Changelog fetching
		def changelogContent = fetchChangelog()

		if (changelogContent) {
			changelogType = "markdown"
			changelog = "Changelog:\n\n${changelogContent}"
		} else {
			afterEvaluate {
				uploadTask.setEnabled(false)
			}
		}

		mainArtifact(remapJar) {
			displayName = "LambdaBetterGrass ${project.mod_version} (${project.minecraft_version})"

			relations {
				requiredDependency "qsl"
				optionalDependency "modmenu"
				incompatible "optifabric"
				incompatible "fabric-api"
			}
		}

		afterEvaluate {
			uploadTask.setGroup("publishing")
			uploadTask.dependsOn("remapJar")
		}
	}
}
tasks.curseforge.setGroup("publishing")

// Configure the maven publication.
publishing {
	publications {
		mavenJava(MavenPublication) {
			from components.java

			pom {
				name = 'LambdaBetterGrass'
				description = 'Adds actual better grass to the game.'
			}
		}
	}

	repositories {
		mavenLocal()
		maven {
			name = 'BuildDirLocal'
			url = "$buildDir/repo"
		}
	}
}