common.gradle

import net.raphimc.javadowngrader.gradle.task.DowngradeJarTask
import org.objectweb.asm.Opcodes

plugins {
	id "dev.architectury.loom" version "1.9-SNAPSHOT" apply false
	id 'com.gradleup.shadow' version '9.0.0-beta4' apply false
	id "com.diffplug.spotless" version "7.0.0.BETA4" apply false
	id "net.raphimc.java-downgrader" version "1.1.2-SNAPSHOT" apply false
	
    // This dependency is only used to determine the state of the Git working tree so that build artifacts can be
    // more easily identified. This setup is copied from sodium
    id 'org.ajoberstar.grgit' version '5.2.1'
}

apply plugin: 'eclipse'
apply plugin: "dev.architectury.loom"
apply plugin: 'com.replaymod.preprocess'
apply plugin: 'com.gradleup.shadow'
apply plugin: 'net.raphimc.java-downgrader'

def mod_brand = (loom.platform.get() as String).toLowerCase()
assert mod_brand in ['fabric', 'forge', 'neoforge']
assert project.name.endsWith('-' + mod_brand)  // optional check

int mcVersion = 1
preprocess {
	mcVersion = vars.get()["MC"] as int
	tabIndentation = false

	vars.put("MC", mcVersion)
	vars.put("FABRIC", mod_brand == 'fabric' ? 1 : 0)
	vars.put("FORGE", mod_brand == 'forge' ? 1 : 0)
	vars.put("NEOFORGE", mod_brand == 'neoforge' ? 1 : 0)
}

loom {
	if (!(mod_brand == 'neoforge' || (mod_brand == 'forge' && mcVersion >= 12005))) {
		println "Creating refmap for version $mcVersion"
		mixin {
			useLegacyMixinAp = true
			defaultRefmapName = "$id$.refmap.mixins.json"
		}
	}
	runConfigs.all {
		// to make sure it generates all "Minecraft Client (:subproject_name)" applications
		ideConfigGenerated = true
		runDir '../../run'
	}
	silentMojangMappingsLicense()
	if (mod_brand == 'forge') {
		forge.mixinConfigs "${modid}.mixins.json"
	}

	if(file("${project.rootProject.rootDir}/src/main/resources/$id$.accesswidener").exists()){
		accessWidenerPath = file("${project.rootProject.rootDir}/src/main/resources/$id$.accesswidener")
	}

	if(file("$projectDir/src/main/resources/$id$.accesswidener").exists()){
		accessWidenerPath = file("$projectDir/src/main/resources/$id$.accesswidener")
	}

}

configurations {
	inc
	implementation.extendsFrom inc
}

dependencies {
	minecraft "com.mojang:minecraft:${project.minecraft_version}"
	mappings loom.layered() {
		officialMojangMappings()
		if (mcVersion >= 12100) {
			parchment("org.parchmentmc.data:parchment-${rootProject.parchment_mc_version_21}:${rootProject.parchment_version_21}@zip")
		} else if (mcVersion >= 12004) {
			parchment("org.parchmentmc.data:parchment-${rootProject.parchment_mc_version_20_4}:${rootProject.parchment_version_20_4}@zip")
		} else if(mcVersion >= 12002) {
			parchment("org.parchmentmc.data:parchment-${rootProject.parchment_mc_version_20_2}:${rootProject.parchment_version_20_2}@zip")
		}
	}

	compileOnly 'org.projectlombok:lombok:1.18.36'
	annotationProcessor 'org.projectlombok:lombok:1.18.36'
	
	testCompileOnly 'org.projectlombok:lombok:1.18.36'
	testAnnotationProcessor 'org.projectlombok:lombok:1.18.36'

	if (mod_brand == 'fabric') {
		modImplementation "net.fabricmc:fabric-loader:${project.fabric_loader_version}"

		modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"
		if(project.hasProperty('mod_menu_compile_only')) {
    		modCompileOnly "maven.modrinth:modmenu:${project.mod_menu_release}"
		} else {
			modImplementation "maven.modrinth:modmenu:${project.mod_menu_release}"
		}

		testImplementation "net.fabricmc:fabric-loader-junit:${rootProject.fabric_loader_version}"
		testImplementation 'org.objenesis:objenesis:3.4'

		$fabric_dependencies$

		if (!file("${project.rootDir}/src/main/resources/fabric.mod.json").exists()) {
			sourceSets.main.resources.srcDirs += "${project.rootDir}/src/main/fabric-resources"
		}
	} else if (mod_brand == 'forge') {
		forge "net.minecraftforge:forge:${project.minecraft_version}-${project.forge_version}"

		forgeRuntimeLibrary project(":$versionlessname$") 

		$forge_dependencies$

		sourceSets.main.resources.srcDirs += "${project.rootDir}/src/main/forge-resources"
	} else if (mod_brand == 'neoforge') {
		neoForge "net.neoforged:neoforge:${project.neoforge_version}"
		forgeRuntimeLibrary project(":$versionlessname$") 

		$neoforge_dependencies$

		sourceSets.main.resources.srcDirs += "${project.rootDir}/src/main/neoforge-resources"
	}

//    sourceSets.main.java.srcDirs += "${project.rootDir}/UtilityCode/${project.minecraft_version}/src/main/java"
//	sourceSets.main.resources.srcDirs += "${project.rootDir}/UtilityCode/${project.minecraft_version}/src/main/resources"

	$dependencies$

	inc project(":$versionlessname$") 

}

if (getFile('dependencies.gradle').exists()) {
    apply from: 'dependencies.gradle'
} else if (getFile('dependencies.gradle.kts').exists()) {
    apply from: 'dependencies.gradle.kts'
}

shadowJar {
	configurations = [project.configurations.inc]
	relocate 'dev.tr7zw.util', '$relocationpackage$.util'
	relocate 'dev.tr7zw.config', '$relocationpackage$.config'
}

remapJar {
	dependsOn(shadowJar)
	input = shadowJar.archiveFile

	doLast {
		// Delete the shadowJar.archiveFile after remapJar task is executed
		delete shadowJar.archiveFile
	}
	if(mcVersion < 11800) {
		finalizedBy("java8Jar")
	} else if (mcVersion <= 12004) {
		finalizedBy("java17Jar")
	}
}

test.onlyIf { mod_brand == 'fabric' && mcVersion >= 11800 }
compileTestJava.onlyIf { mod_brand == 'fabric' && mcVersion >= 11800 }

test {
	useJUnitPlatform()
}

processResources {
	duplicatesStrategy(DuplicatesStrategy.EXCLUDE)

	def neoforgeVersionRange = project.hasProperty('neo_version_range') ? project.neo_version_range : ''
	def neoforgeLoaderVersion = project.hasProperty('loader_version_range_neoforge') ? project.loader_version_range_neoforge : ''
	def forgeLoaderVersion = project.hasProperty('loader_version_range_forge') ? project.loader_version_range_forge : ''
	def fabricApiName = project.hasProperty('fabric_api_name') ? project.fabric_api_name : ''

	def versionsMap = [
		10809: 1,
		11202: 3,
		11500: 5,
		11605: 6,
		11701: 7,
		11802: 8,
		11902: 9,
		11903: 12,
		11904: 13,
		12001: 15,
		12002: 18,
		12003: 21,
		12004: 22,
		12005: 32,
		12006: 32,
		12100: 34,
		12102: 42,
		12103: 42,
		12104: 46
	]

	var replaceProperties = [
			minecraft_version   : minecraft_version, minecraft_version_range_forge: minecraft_dependency,
			minecraft_version_range_neoforge         : minecraft_dependency,
			minecraft_version_range_fabric: minecraft_dependency,
			loader_version_range_neoforge: neoforgeLoaderVersion,
			loader_version_range_forge: forgeLoaderVersion,
			neo_version_range: neoforgeVersionRange,
			fabric_entrypoint   : "$fabric_entrypoint$",
			fabric_modmenu_entrypoint: "$fabric_modmenu_entrypoint$",
			fabric_api_name: fabricApiName,
			description		 : "$description$",
			homepage_url		 : "$homepageUrl$",
			sources_url		 : "$sourcesUrl$",
			issues_url		 : "$issuesUrl$",
			license_name: "$licenseName$",
			mod_id              : "$id$", mod_name: "$name$", version: "$version$${getVersionMetadata()}",
			mod_author         : "$author$", pack_format_number: versionsMap[mcVersion],
	]
	inputs.properties replaceProperties

	filesMatching(['fabric.mod.json', 'META-INF/mods.toml', 'META-INF/neoforge.mods.toml', '**/pack.mcmeta']) {
		expand replaceProperties + [project: project]
	}

	from "${project.rootDir}/$licensename$"

	if (mod_brand != 'fabric') {
		exclude {
			it.file.name == 'fabric.mod.json'
		}
	}

}

sourceSets.each {
	def dir = layout.buildDirectory.dir("sourcesSets/$it.name")
	it.output.resourcesDir = dir
	it.java.destinationDirectory = dir
}

afterEvaluate { project ->
	project.tasks.withType(JavaExec).configureEach { task ->
		if (task.name.startsWith("runClient")) {
			task.doFirst {
				def binDir = project.file('bin')
				if (binDir.exists()) {
					deleteBinDir(binDir)
				}

			}
		}
	}
}

archivesBaseName = rootProject.archives_base_name
version = mod_brand + "-" + rootProject.mod_version + "-mc" + project.minecraft_version + getVersionMetadata()
group = rootProject.maven_group

repositories {
	// Add repositories to retrieve artifacts from in here.
	// You should only use this when depending on other mods because
	// Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
	// See https://docs.gradle.org/current/userguide/declaring_repositories.html
	// for more information about repositories.
	maven {
		name = "tr7zw-proxy"
		url "https://maven.tr7zw.dev/repository/maven-public/"
	}
	maven {
		name = "Modrinth"
		url = "https://api.modrinth.com/maven"
		content {
			includeGroup "maven.modrinth"
		}
	}
	maven {
		url "https://cursemaven.com"
	}
	mavenLocal()
}

tasks.withType(JavaCompile) {
	options.encoding = "UTF-8"
}

// remapping the jars later for <= 1.20.4 to Java 17
// remapping the jars later for < 1.18 to Java 8
sourceCompatibility = JavaVersion.VERSION_21
targetCompatibility = JavaVersion.VERSION_21

java {
	//withSourcesJar()
}

def getVersionMetadata() {
    // CI builds only
    if (project.hasProperty("build.release")) {
        return "" // no tag whatsoever
    }

    if (grgit != null) {
        def head = grgit.head()
        def id = head.abbreviatedId

        // Flag the build if the build tree is not clean
        if (!grgit.status().isClean()) {
            id += "-dirty"
            println "Changes: " + grgit.status().staged.getAllChanges() + " " + grgit.status().unstaged.getAllChanges()
        }

        return "+git.${id}"
    }

    // No tracking information could be found about the build
    return "+unknown"
}

// Function to delete bin directory recursively
def deleteBinDir(dir) {
    ant.delete(dir: dir, failonerror: false)
}

tasks.register("java8Jar", DowngradeJarTask) {
	dependsOn remapJar
	input = tasks.remapJar.archiveFile.get().asFile
    outputSuffix = "+java8"
    compileClassPath = sourceSets.main.compileClasspath
    copyRuntimeClasses = false
	doLast {
		// Delete the remapJar.archiveFile
		delete remapJar.archiveFile
		def inputFile = tasks.remapJar.archiveFile.get().asFile
        def outputDirectory = inputFile.parent
        def originalFileName = inputFile.getName().substring(0, inputFile.getName().length() - 4);

        // Renaming the generated file to the original name
        def generatedFile = new File(outputDirectory, "${originalFileName}+java8.jar")
        generatedFile.renameTo(inputFile)
	}
}

tasks.register("java17Jar", DowngradeJarTask) {
	dependsOn remapJar
	input = tasks.remapJar.archiveFile.get().asFile
    outputSuffix = "+java17"
    compileClassPath = sourceSets.main.compileClasspath
    copyRuntimeClasses = false
	targetVersion = Opcodes.V17
	doLast {
		// Delete the remapJar.archiveFile
		delete remapJar.archiveFile
		def inputFile = tasks.remapJar.archiveFile.get().asFile
        def outputDirectory = inputFile.parent
        def originalFileName = inputFile.getName().substring(0, inputFile.getName().length() - 4);

        // Renaming the generated file to the original name
        def generatedFile = new File(outputDirectory, "${originalFileName}+java17.jar")
        generatedFile.renameTo(inputFile)
	}
}

def getFile(String relativePath) {
    return new File(projectDir, relativePath)
}