AutoModLoaderVersion.gradle

import groovy.json.JsonSlurper
import groovy.json.JsonOutput
import groovy.xml.XmlSlurper

def normalizeMcVersion = { mcVersion ->
    def parts = mcVersion.tokenize(".")
    while (parts.size() < 3) parts << "0"
    return parts[0..2].join(".")  // ignore extra pre-release parts
}


def mcVersion = project.minecraft_version
// Helper to load cache if it exists
def loadCache() {
    def cacheFile = file("${project.rootDir}/build/cache/loaderVersionsCache_${project.minecraft_version}.json")
    if (cacheFile.exists()) {
        def cache = new JsonSlurper().parse(cacheFile)
        if (cache.minecraft_version == project.minecraft_version) {
            println("Using cached loader versions for Minecraft $project.minecraft_version")
            return cache
        }
    }
    return null
}

// Helper to save cache
def saveCache(mcVersion, cacheMap) {
    def cacheFile = file("${project.rootDir}/build/cache/loaderVersionsCache_${mcVersion}.json")
    cacheFile.parentFile.mkdirs()
    cacheFile.text = JsonOutput.prettyPrint(JsonOutput.toJson(cacheMap))
    println("Saved loader versions cache")
}

// Helpers to fetch JSON / XML
def fetchJson = { url ->
    try {
        println("Fetching: $url")
        return new JsonSlurper().parse(new URL(url))
    } catch (Exception e) {
        println("Failed to fetch JSON from $url : ${e.class.simpleName} - ${e.message}")
        return null
    }
}

def fetchXml = { url ->
    try {
        println("Fetching: $url")
        return new XmlSlurper().parse(new URL(url).openStream())
    } catch (Exception e) {
        println("Failed to fetch XML from $url : ${e.class.simpleName} - ${e.message}")
        return null
    }
}




// Try load cache
def cache = loadCache()
if (cache) {
    ext.fabric_version = cache.fabric_version
    ext.fabric_loader_version = cache.fabric_loader_version
    ext.neoforge_version = cache.neoforge_version
    ext.neoforge_loader_version_range = cache.neoforge_loader_version_range
    ext.forge_version = cache.forge_version
    ext.forge_loader_version_range = cache.forge_loader_version_range
    ext.neo_form_version = cache.neo_form_version
    ext.parchment_minecraft = mcVersion
    ext.parchment_version = cache.parchment_version
} else {
    // ------------------------------ PERCHANTMENT ------------------------------
    def perchantmentMeta = fetchXml("https://maven.parchmentmc.org/org/parchmentmc/data/parchment-${mcVersion}/maven-metadata.xml")
    if(perchantmentMeta != null) {
        ext.parchment_version = "$perchantmentMeta.versioning.release"
        ext.parchment_minecraft = mcVersion
    } else {
        ext.parchment_version = null
        ext.parchment_minecraft = mcVersion
    }
    // ------------------------------ FABRIC ------------------------------
    def fabricMeta = fetchXml("https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api/maven-metadata.xml")
    def fabricLoaderMeta = fetchJson("https://meta.fabricmc.net/v2/versions/loader/$mcVersion")
    if(fabricMeta != null && fabricLoaderMeta != null) {
        def fabricVersions = fabricMeta.versioning.versions.version*.text()
        def fabricVersionContainer = fabricVersions.findAll { it.contains(mcVersion) }
        ext.fabric_version = fabricVersionContainer.max()
        ext.fabric_loader_version = fabricLoaderMeta[0]?.loader?.version
    } else {
        ext.fabric_version = null;
        ext.fabric_loader_version = null;
    }
    // ------------------------------ NEOFORGE ------------------------------
    def neoforgeMeta = fetchXml("https://maven.neoforged.net/releases/net/neoforged/neoforge/maven-metadata.xml")
    if(neoforgeMeta != null) {
        def neoforgeVersions = neoforgeMeta.versioning.versions.version*.text()
        def tokMcVersion = normalizeMcVersion(mcVersion)
        def mcParts = tokMcVersion.split("\\.")   // ["1","21","9"]
        def mcPrefix = mcParts[1] + "." + mcParts[2]
        def matchingVersions = neoforgeVersions.findAll { it.startsWith(mcPrefix + ".") }
        def neoVersionComparator = { a, b ->
            def aParts = a.substring(a.indexOf(".") + 1).tokenize(".-")
            def bParts = b.substring(b.indexOf(".") + 1).tokenize(".-")
            for (int i = 0; i < Math.max(aParts.size(), bParts.size()); i++) {
                def aVal = i < aParts.size() ? aParts[i].replaceAll("\\D.*", "").toInteger() : 0
                def bVal = i < bParts.size() ? bParts[i].replaceAll("\\D.*", "").toInteger() : 0
                if (aVal != bVal) return aVal <=> bVal
            }
            return 0
        }
        ext.neoforge_version = matchingVersions.max(neoVersionComparator)
        ext.neoforge_loader_version_range = "[4,)"
    } else {
        ext.neoforge_version = null;
        ext.neoforge_loader_version_range = null;
    }

    // ------------------------------ FORGE ------------------------------
    def forgeMeta = fetchJson("https://files.minecraftforge.net/net/minecraftforge/forge/maven-metadata.json")
    if(forgeMeta != null) {
        def matchingList = forgeMeta[mcVersion] ?: []
        ext.forge_version = matchingList.max().split("-")[1] ?: "UNKNOWN"
        ext.forge_loader_version_range = "[${forge_version.split("\\.")[0]},)"
    } else {
        ext.forge_version = null;
        ext.forge_loader_version_range = null;
    }

    // ------------------------------ NEOFORM ------------------------------
    def neoformMeta = fetchXml("https://maven.neoforged.net/releases/net/neoforged/neoform/maven-metadata.xml")
    if(neoformMeta != null){
        def allVersions = neoformMeta.versioning.versions.version*.text()
        def neoformVersions = allVersions.findAll { it.startsWith(mcVersion) }
        ext.neo_form_version = mcVersion == "1.21.11" ? "1.21.11-20251209.172050" : neoformVersions.max();
    } else {
        ext.neo_form_version = null;
    }

    // ------------------------------ SAVE CACHE ------------------------------
    saveCache(mcVersion, [
            minecraft_version: mcVersion,
            fabric_version: ext.fabric_version,
            fabric_loader_version: ext.fabric_loader_version,
            neoforge_version: ext.neoforge_version,
            neoforge_loader_version_range: ext.neoforge_loader_version_range,
            forge_version: ext.forge_version,
            forge_loader_version_range: ext.forge_loader_version_range,
            neo_form_version: ext.neo_form_version,
            parchment_version: ext.parchment_version,
    ])
}

ext.minecraft_version_range = VersionUtil.getVersionsFromDirectory(project.rootDir.toString(), VersionUtil.getDirectory(project.rootDir.toString(), project.minecraft_version.toString()))
println("Supported Minecraft Versions: $ext.minecraft_version_range")
println("Fabric: $ext.fabric_version | Fabric Loader: $ext.fabric_loader_version")
println("NeoForge: $ext.neoforge_version | NeoForge Loader Range: $ext.neoforge_loader_version_range")
println("Forge: $ext.forge_version | Forge Loader Range: $ext.forge_loader_version_range")
println("NeoForm: $ext.neo_form_version")
println("Parchment Version: $ext.parchment_version")