XFEServerManager

group = 'com.xfestudio.xfeservermanager'

// Materialise Gradle properties during configuration.  Gradle 9's configuration-cache
// isolation rejects references to the script's ProviderFactory from task actions (for
// example Jar.rename/manifest closures), even when the provider is queried immediately.
def modIdValue = providers.gradleProperty('mod_id').get()
def modNameValue = providers.gradleProperty('mod_name').get()
def modVersionValue = providers.gradleProperty('mod_version').get()
def modAuthorsValue = providers.gradleProperty('mod_authors').get()
def minecraftVersionValue = providers.gradleProperty('minecraft_version').get()
def javaVersionValue = providers.gradleProperty('java_version').get().toInteger()
def forgeEventApiValue = providers.gradleProperty('forge_event_api').get()
def mavenizerJavaVersion = providers.gradleProperty('xfesm_mavenizer_java_version').orNull

// ForgeGradle 7's Mavenizer is compiled for Java 25. Keep the mod toolchain at
// Minecraft's required Java version, but allow the build script to select an
// installed JDK 25+ for that isolated build tool.
def forgeTools = extensions.findByName('fgtools')
if (forgeTools != null && mavenizerJavaVersion != null) {
    forgeTools.configure('mavenizer') {
        javaLauncher.set(javaToolchains.launcherFor {
            languageVersion = JavaLanguageVersion.of(mavenizerJavaVersion.toInteger())
        })
    }
}

version = modVersionValue
def builtWebDirectory = rootProject.file('../../web-ui/dist')

base {
    archivesName = "${modIdValue}-forge-${minecraftVersionValue}"
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(javaVersionValue)
    }
    withSourcesJar()
}

sourceSets {
    main {
        java {
            srcDir rootProject.file('../shared/src/main/java')
            srcDir rootProject.file('../shared/src/forge-common/java')
            if (forgeEventApiValue == 'legacy') {
                srcDir rootProject.file('../shared/src/forge-legacy/java')
            }

            // The stable API and policy engine are compiled into every platform jar. They deliberately
            // contain no Minecraft or Forge references, so the four standalone builds remain isolated.
            srcDir rootProject.file('../../common/api/src/main/java')
            srcDir rootProject.file('../../common/core/src/main/java')
            srcDir rootProject.file('../../common/infra/src/main/java')
        }
        resources {
            srcDir rootProject.file('../shared/src/main/resources')
            srcDir rootProject.file('../../common/api/src/main/resources')
            srcDir rootProject.file('../../common/core/src/main/resources')
            srcDir rootProject.file('../../common/infra/src/main/resources')
            if (builtWebDirectory.isDirectory()) {
                // The infra module ships a minimal emergency page. A release UI must replace it,
                // never coexist as a duplicate ZIP entry whose lookup order is unspecified.
                exclude 'web/**'
            }
        }
    }
    test {
        java.srcDir rootProject.file('../shared/src/test/java')
    }
}

dependencyLocking {
    lockAllConfigurations()
}

dependencies {
    testImplementation platform('org.junit:junit-bom:5.11.4')
    testImplementation 'org.junit.jupiter:junit-jupiter'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.named('test', Test).configure {
    useJUnitPlatform()
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.release = javaVersionValue
    options.compilerArgs.addAll(['-parameters', '-Xlint:all'])
}

def resourceTokens = [
        mod_id                 : modIdValue,
        mod_name               : modNameValue,
        mod_version            : modVersionValue,
        mod_license            : providers.gradleProperty('mod_license').get(),
        mod_authors            : modAuthorsValue,
        mod_description        : providers.gradleProperty('mod_description').get(),
        minecraft_version      : minecraftVersionValue,
        minecraft_version_range: providers.gradleProperty('minecraft_version_range').get(),
        forge_version          : providers.gradleProperty('forge_version').get(),
        forge_version_range    : providers.gradleProperty('forge_version_range').get(),
        loader_version_range   : providers.gradleProperty('loader_version_range').get()
]

tasks.named('processResources').configure {
    inputs.properties(resourceTokens)
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    filesMatching(['META-INF/mods.toml', 'xfesm-build.properties']) {
        expand(resourceTokens)
    }

    // Vite output is optional during platform-only development. Without it the infra fallback is retained.
    if (builtWebDirectory.isDirectory()) {
        from(builtWebDirectory) {
            into 'web'
        }
    }
}

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

tasks.named('jar', Jar).configure {
    from(rootProject.file('../../LICENSE')) {
        rename { "META-INF/LICENSE_${modIdValue}" }
    }
    manifest {
        attributes([
                'Specification-Title'   : modNameValue,
                'Specification-Vendor'  : modAuthorsValue,
                'Specification-Version' : '1',
                'Implementation-Title'  : modNameValue,
                'Implementation-Version': modVersionValue,
                'Implementation-Vendor' : modAuthorsValue,
                'MixinConfigs'          : 'xfeservermanager.mixins.json'
        ])
    }
}