build.gradle

import com.modrinth.minotaur.TaskModrinthUpload
import com.modrinth.minotaur.dependencies.ModDependency
import com.modrinth.minotaur.dependencies.VersionDependency
import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import mekanism.MergeJars

plugins {
    id 'org.ajoberstar.grgit' version '4.1.1'//'5.0.0'//Can't use 5.0.0 yet as our jenkins uses java 8 to run gradle
    id "com.matthewprenger.cursegradle" version '1.4.0'
    id "com.modrinth.minotaur" version "2.+"
    id 'java'
    id 'eclipse'
    id 'idea'
    id 'maven-publish'
    id 'net.minecraftforge.gradle' version '5.+'
    id 'org.parchmentmc.librarian.forgegradle' version '1.+'
}

wrapper {
    //Define wrapper values here so as to not have to always do so when updating gradlew.properties
    gradleVersion = '7.4.2'
    distributionType = Wrapper.DistributionType.ALL
}

defaultTasks 'build'

idea {
    module {
        // For some reason this is necessary for IDEA 2014 workspaces to recognize assets
        inheritOutputDirs = true
        //Exclude directories from being managed
        for (String excludeDirName in ["run", "out", "logs", "gradle"]) {
            excludeDirs.add(new File(projectDir, excludeDirName))
        }
    }
}

sourceSets {
    api {
        //The API has no resources
        resources.srcDirs = []
    }
    main {
        resources {
            include '**/**'
            // copy everything else, but blender and bbmodel files.
            exclude '**/*.blend'
            exclude '**/*.bbmodel'
            //Add the generated main module resources, as well as those generated by the annotation processor
            srcDirs += ['src/datagen/generated/mekanism', 'src/datagen/main/annotation_generated']
            //But exclude the cache of the generated data from what gets built
            exclude '.cache'
        }
        compileClasspath += api.output
        runtimeClasspath += api.output
    }
    additions { setupSourceSet(additions, 'additions') }
    generators { setupSourceSet(generators, 'generators') }
    defense { setupSourceSet(defense, 'defense') }
    tools { setupSourceSet(tools, 'tools') }
    test {
        //The test module has no resources
        resources.srcDirs = []
        compileClasspath += api.output + main.output + additions.output + generators.output + defense.output + tools.output
        runtimeClasspath += api.output + main.output + additions.output + generators.output + defense.output + tools.output
    }
    //Data gen modules for the different modules
    datagenmain { setupDataGenSourceSet(datagenmain, null, 'main') }
    datagenadditions { setupDataGenSourceSet(datagenadditions, additions, 'additions') }
    datagengenerators { setupDataGenSourceSet(datagengenerators, generators, 'generators') }
    datagendefense { setupDataGenSourceSet(datagendefense, defense, 'defense') }
    datagentools { setupDataGenSourceSet(datagentools, tools, 'tools') }
}

//This method sets up an additional sourceSet in src/$name and adds a reference to the corresponding
// data gen's resource directory excluding the cache. It also adds the api and main mekanism module
// to the dependencies of the source set we are setting up
def setupSourceSet(SourceSet sourceSet, String name) {
    sourceSet.resources {
        //Add the generated module resources, as well as those that might be generated by the annotation processor
        srcDirs += ["src/datagen/generated/mekanism${name}", "src/datagen/${name}/annotation_generated"]
        //But exclude the cache of the generated data from what gets built
        exclude '.cache'
    }
    sourceSet.compileClasspath += sourceSets.api.output
    sourceSet.compileClasspath += sourceSets.main.output
}

//This method sets up a source set in datagen/$name and adds the api, main mekanism module and an optional
// base module to the dependencies of the data generators source set that we are setting up
def setupDataGenSourceSet(SourceSet datagenSourceSet, SourceSet baseSourceSet, String name) {
    datagenSourceSet.java.srcDirs = ["src/datagen/${name}/java"]
    //Resources folder for if we have anything get created by our annotation processors
    datagenSourceSet.resources.srcDirs = ["src/datagen/${name}/resources"]
    datagenSourceSet.compileClasspath += project.sourceSets.api.output
    datagenSourceSet.compileClasspath += project.sourceSets.main.output
    if (baseSourceSet != null) {
        //Only case it is null is when we are doing datagenmain so other cases also add access to the stuff
        // in datagenmain so we can add helper classes
        datagenSourceSet.compileClasspath += project.sourceSets.datagenmain.output
        datagenSourceSet.compileClasspath += baseSourceSet.output
    }
}

configurations {
    //Make sure all our sub source set stuff extends the proper base methods so that
    // they can see all the dependencies we have in dependencies including forge
    extendConfigurations(implementation, apiImplementation, testImplementation, datagenmainImplementation)
    extendConfigurations(compileOnly, apiCompileOnly, testCompileOnly, datagenmainCompileOnly)
    extendConfigurations(runtimeOnly, apiRuntimeOnly, datagenmainRuntimeOnly)
    //Extend configurations for alternate modules. First by making the implementation, compileOnly, runtimeOnly equivalents
    // for those modules extend the main ones, and then by making the corresponding ones for datagen for the module extend those.
    // This way if we add a dependency/integration in a submodule instead of the main module of Mekanism, the datagen of the corresponding
    // module will be able to properly access the dependency
    for (def name : ["additions", "defense", "generators", "tools"]) {
        maybeCreate("datagen${name}Implementation").extendsFrom(maybeCreate("${name}Implementation").extendsFrom(implementation))
        maybeCreate("datagen${name}CompileOnly").extendsFrom(maybeCreate("${name}CompileOnly").extendsFrom(compileOnly))
        maybeCreate("datagen${name}RuntimeOnly").extendsFrom(maybeCreate("${name}RuntimeOnly").extendsFrom(runtimeOnly))
    }
}

static void extendConfigurations(Configuration base, Configuration... configurations) {
    for (def configuration : configurations) {
        configuration.extendsFrom(base)
    }
}

ext {
    versionProperties = ["version"                : mod_version, "mc_version": minecraft_version_range, "forge_version": forge_version_range,
                         "loader_version"         : loader_version_range, "crafttweaker_version": crafttweaker_version_range, "jei_version": jei_version_range,
                         "wildfire_gender_version": wildfire_gender_version_range, "curios_version": curios_version_range]
    jsonPatterns = ["**/*.json", "**/*.mcmeta"]
}

def mainReplaceResources = createReplaceResourcesTask("main", sourceSets.main)
def additionsReplaceResources = createReplaceResourcesTask("additions", sourceSets.additions)
def generatorsReplaceResources = createReplaceResourcesTask("generators", sourceSets.generators)
def defenseReplaceResources = createReplaceResourcesTask("defense", sourceSets.defense)
def toolsReplaceResources = createReplaceResourcesTask("tools", sourceSets.tools)

def createReplaceResourcesTask(String output, SourceSet sourceSet) {
    return tasks.register("${output}ReplaceResources", Copy, it -> {
        it.outputs.upToDateWhen { false }
        def modsToml = copySpec {
            from(sourceSet.resources) {
                include "META-INF/mods.toml"
                expand versionProperties
            }
        }
        //Copy it into the build dir
        it.with modsToml
        it.into "$buildDir/resources/${output}/"
        //If IntelliJ's output dir exists, copy it there as well
        if (new File("$rootDir/out/production/Mekanism.${output}/").exists()) {
            //Note: This copies it into the correct place, but it still doesn't have the IntelliJ
            // run work by default because of incorrect MOD_CLASSES getting generated.
            // probably related to us setting inheritOutputDirs
            copy {
                with modsToml
                into "$rootDir/out/production/Mekanism.${output}/"
            }
        }
        //If Eclipse's output dir exists, copy it there as well
        if (new File("$rootDir/bin/${output}/").exists()) {
            copy {
                with modsToml
                into "$rootDir/bin/${output}/"
            }
        }
    })
}

group = "mekanism"
def basicVersion = "${mod_version}." + (System.env.BUILD_NUMBER ?: "homebaked")
version = "${minecraft_version}-${basicVersion}"
archivesBaseName = "Mekanism"
java.toolchain.languageVersion = JavaLanguageVersion.of("${java_version}")

minecraft {
    mappings channel: "${mappings_channel}", version: "${mappings_version}"

    accessTransformers.from(file('src/main/resources/META-INF/accesstransformer.cfg'),
            file('src/additions/resources/META-INF/accesstransformer.cfg'))

    runs {
        client {
            workingDirectory file("run")
            //We aren't a multi-project config so we can disable the forced exit to allow gradle run tasks to stop gracefully
            forceExit = false
            //This fixes Mixin application problems from other mods because their refMaps are SRG-based, but we're in a MCP env
            property 'mixin.env.remapRefMap', 'true'
            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"

            //The below if statements are to add args to your gradle.properties file in user home
            // (DO NOT add them directly to the gradle.properties file for this project)
            // Setting the below properties allows use of your normal Minecraft account in the
            // dev environment including having your skin load. Each property also has a comment
            // explaining what information to set the value to/format it expects
            // One thing to note is because of the caching that goes on, after changing these
            // variables, you need to refresh the project and rerun genIntellijRuns/genEclipseRuns
            if (project.hasProperty('mc_uuid')) {
                //Your uuid without any dashes in the middle
                args '--uuid', project.getProperty('mc_uuid')
            }
            if (project.hasProperty('mc_username')) {
                //Your username/display name, this is the name that shows up in chat
                // Note: This is not your email, even if you have a Mojang account
                args '--username', project.getProperty('mc_username')
            }
            if (project.hasProperty('mc_accessToken')) {
                //Your access token, you can find it in your '.minecraft/launcher_accounts.json' file
                args '--accessToken', project.getProperty('mc_accessToken')
            }
            if (project.hasProperty('forge_force_ansi')) {
                //Force ansi if declared as a gradle variable, as the auto detection doesn't detect IntelliJ properly
                // or eclipse's plugin that adds support for ansi escape in console
                jvmArg('-Dterminal.ansi=' + project.getProperty('forge_force_ansi'))
            }

            mods {
                mekanism.sources((SourceSet[]) [sourceSets.main, sourceSets.api])
                mekanismadditions.source((SourceSet) sourceSets.additions)
                mekanismdefense.source((SourceSet) sourceSets.defense)
                mekanismgenerators.source((SourceSet) sourceSets.generators)
                mekanismtools.source((SourceSet) sourceSets.tools)
            }
        }

        server {
            workingDirectory file("run")
            //We aren't a multi-project config so we can disable the forced exit to allow gradle run tasks to stop gracefully
            forceExit = false
            //This fixes Mixin application problems from other mods because their refMaps are SRG-based, but we're in a MCP env
            property 'mixin.env.remapRefMap', 'true'
            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"

            if (project.hasProperty('forge_force_ansi')) {
                //Force ansi if declared as a gradle variable, as the auto detection doesn't detect IntelliJ properly
                // or eclipse's plugin that adds support for ansi escape in console
                jvmArg('-Dterminal.ansi=' + project.getProperty('forge_force_ansi'))
            }

            mods {
                mekanism.sources((SourceSet[]) [sourceSets.main, sourceSets.api])
                mekanismadditions.source((SourceSet) sourceSets.additions)
                mekanismdefense.source((SourceSet) sourceSets.defense)
                mekanismgenerators.source((SourceSet) sourceSets.generators)
                mekanismtools.source((SourceSet) sourceSets.tools)
            }
        }

        data {
            workingDirectory file("run")
            environment 'target', 'fmluserdevdata'
            //We aren't a multi-project config so we can disable the forced exit to allow gradle run tasks to stop gracefully
            forceExit = false
            //This fixes Mixin application problems from other mods because their refMaps are SRG-based, but we're in a MCP env
            property 'mixin.env.remapRefMap', 'true'
            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"

            if (project.hasProperty('forge_force_ansi')) {
                //Force ansi if declared as a gradle variable, as the auto detection doesn't detect IntelliJ properly
                // or eclipse's plugin that adds support for ansi escape in console
                jvmArg('-Dterminal.ansi=' + project.getProperty('forge_force_ansi'))
            }

            args '--all', '--output', file('src/datagen/generated/'),
                    '--mod', 'mekanism',
                    '--existing', file('src/main/resources/'),
                    '--mod', 'mekanismadditions',
                    '--existing', file('src/additions/resources/'),
                    '--mod', 'mekanismdefense',
                    '--existing', file('src/defense/resources/'),
                    '--mod', 'mekanismgenerators',
                    '--existing', file('src/generators/resources/'),
                    '--mod', 'mekanismtools',
                    '--existing', file('src/tools/resources/')

            mods {
                mekanism.sources((SourceSet[]) [sourceSets.main, sourceSets.api, sourceSets.datagenmain])
                mekanismadditions.sources((SourceSet[]) [sourceSets.additions, sourceSets.datagenadditions])
                mekanismdefense.sources((SourceSet[]) [sourceSets.defense, sourceSets.datagendefense])
                mekanismgenerators.sources((SourceSet[]) [sourceSets.generators, sourceSets.datagengenerators])
                mekanismtools.sources((SourceSet[]) [sourceSets.tools, sourceSets.datagentools])
            }
        }
    }
}

repositories {
    maven {
        name 'thiakil'
        url 'https://maven.thiakil.com'
        content {
            includeGroup 'de.oceanlabs.mcp'
            includeGroup 'net.minecraft'//custom mappings
        }
    }
    maven {
        name 'prog'
        url 'https://dvs1.progwml6.com/files/maven'
        content {
            includeGroup 'mezz.jei'
        }
    }
    maven {
        name 'CraftTweaker'
        url "https://maven.blamejared.com"
        content {
            includeGroup 'com.blamejared.crafttweaker'
            includeGroup 'com.blamejared.jeitweaker'
        }
    }
    maven {
        name 'curios'
        url "https://maven.theillusivec4.top/"
        content {
            includeGroup 'top.theillusivec4.curios'
        }
    }
    maven {
        name 'tterrag'
        url 'https://maven.tterrag.com/'
        content {
            includeGroup 'team.chisel.ctm'
        }
    }
    maven {
        name 'CurseMaven'
        url 'https://www.cursemaven.com'
        content {
            includeGroup 'curse.maven'
        }
    }
    maven {
        name 'Modmaven'
        url 'https://modmaven.dev/'
        content {
            includeGroup 'appeng'
            includeGroup 'mcjty.theoneprobe'
        }
    }

    whenObjectAdded {//ForgeGradle adds these in an afterEvaluate, so we need to catch them as they're added and exclude mod artifacts/groups
        if (it instanceof MavenArtifactRepository) {
            def url = it.url.toString()
            if (url == 'https://maven.minecraftforge.net/' || url == 'https://libraries.minecraft.net/' || url == 'https://repo.maven.apache.org/maven2/') {
                try {
                    it.content {
                        excludeGroup 'curse.maven'
                        excludeGroup 'mezz.jei'
                        excludeGroup 'mcjty.theoneprobe'
                        excludeGroup 'team.chisel.ctm'
                        excludeGroup 'appeng'
                        excludeGroup 'com.blamejared.crafttweaker'
                        excludeGroup 'com.blamejared.jeitweaker'
                        excludeGroup 'top.theillusivec4.curios'
                    }
                    println("Adding exclusions to ${it.url}")
                } catch (Exception ignored) {
                    //oh well
                }
            }
        }
    }
}

test {
    useJUnitPlatform()
}

dependencies {
    minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"

    annotationProcessor project(":annotation-processor")

    testImplementation "org.junit.jupiter:junit-jupiter-api:${junit_version}"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_version}"
    //We use https://github.com/quicktheories/QuickTheories to allow for implementing property based testing
    testImplementation "org.quicktheories:quicktheories:${quicktheories_version}"

    compileOnly "org.jetbrains:annotations:${jb_annotations}"

    compileOnly fg.deobf("mezz.jei:jei-${minecraft_version}:${jei_version}:api")
    runtimeOnly fg.deobf("mezz.jei:jei-${minecraft_version}:${jei_version}")

    //TODO: Re-enable in dev once https://github.com/Chisel-Team/ConnectedTexturesMod/issues/174 is fixed
    //runtimeOnly fg.deobf("team.chisel.ctm:CTM:${minecraft_version}-${ctm_version}")

    //TODO: Remove having to specify these as non transitive once https://github.com/McJtyMods/TheOneProbe/issues/548 is fixed
    compileOnly fg.deobf("mcjty.theoneprobe:theoneprobe:${top_version}:api") {
        transitive = false
    }
    runtimeOnly fg.deobf("mcjty.theoneprobe:theoneprobe:${top_version}") {
        transitive = false
    }

    compileOnly fg.deobf("curse.maven:jade-api-324717:${jade_api_id}")
    runtimeOnly fg.deobf("curse.maven:jade-324717:${jade_id}")

    implementation fg.deobf("com.blamejared.crafttweaker:CraftTweaker-forge-${minecraft_version}:${crafttweaker_version}")
    implementation fg.deobf("com.blamejared.jeitweaker:JEITweaker-${minecraft_version}:${jeitweaker_version}")

    //Mods we have dependencies on but don't bother loading into the dev environment
    compileOnly fg.deobf("curse.maven:projecte-api-226410:${projecte_api_id}")
    //TODO - 1.18: Support flux networks again when it ports
    //compileOnly fg.deobf("curse.maven:flux-networks-248020:${flux_networks_id}")
    compileOnly fg.deobf("top.theillusivec4.curios:curios-forge:${minecraft_version}-${curios_version}:api")
    compileOnly fg.deobf("curse.maven:opencomputers2-437654:${oc2_id}")
    def cc = fg.deobf("curse.maven:cc-tweaked-282001:${cc_tweaked_id}")
    compileOnly cc
    //We require cc tweaked so that our CCArgumentWrapper tests can load, so expose it to the test runtime
    testRuntimeOnly cc
    compileOnly fg.deobf("curse.maven:female-gender-forge-481655:${wildfire_gender_mod_id}")

    //Dependencies for data generators for mod compat reference
    datagenmainImplementation fg.deobf("appeng:appliedenergistics2:${ae2_version}")
    datagenmainCompileOnly fg.deobf("curse.maven:biomes-o-plenty-api-220318:${biomesoplenty_api_id}")
    datagenmainRuntimeOnly fg.deobf("curse.maven:biomes-o-plenty-220318:${biomesoplenty_id}")
    datagenmainRuntimeOnly fg.deobf("curse.maven:terrablender-563928:${terrablender_id}")//Biomes O' Plenty dep
    datagenmainImplementation fg.deobf("curse.maven:biomes-youll-go-247560:${byg_id}")
    datagenmainImplementation fg.deobf("curse.maven:i-like-wood-324164:${ilikewood_id}")
    datagenmainImplementation fg.deobf("curse.maven:i-like-wood-biomes-o-plenty-437203:${ilikewood_bop_id}")
    datagenmainImplementation fg.deobf("curse.maven:i-like-wood-oh-the-biomes-youll-go-475110:${ilikewood_byg_id}")
    datagenmainRuntimeOnly fg.deobf("curse.maven:projecte-226410:${projecte_id}")
}

if (project.hasProperty('UPDATE_MAPPINGS')) {
    //If the project has the update mappings property, configure it to be able to target all our extra sourceSets as well
    // so that whenever we need to update mappings it is quick and easy to do so.
    // Note: This needs to be below the dependencies and minecraft blocks so that it can properly read the mappings value
    // and also read and find the minecraft dep
    def extraSourceSets = [sourceSets.api, sourceSets.additions, sourceSets.generators, sourceSets.defense, sourceSets.tools, sourceSets.test,
                           sourceSets.datagenmain, sourceSets.datagenadditions, sourceSets.datagengenerators, sourceSets.datagendefense, sourceSets.datagentools]
    Set<File> allExtraDirs = new HashSet<>()
    for (def sourceSet : extraSourceSets) {
        allExtraDirs.addAll(sourceSet.java.srcDirs)
    }
    extractRangeMap {
        sources.from(allExtraDirs)
    }
    applyRangeMap {
        sources.from(allExtraDirs)
    }
    allExtraDirs.each { extractMappedNew.addTarget it }
}

//Set the various variables/settings for the different process resources tasks
processResources { setupProcessResources(processResources, mainReplaceResources, compileJava) }
processAdditionsResources { setupProcessResources(processAdditionsResources, additionsReplaceResources, compileAdditionsJava) }
processDefenseResources { setupProcessResources(processDefenseResources, defenseReplaceResources, compileDefenseJava) }
processGeneratorsResources { setupProcessResources(processGeneratorsResources, generatorsReplaceResources, compileGeneratorsJava) }
processToolsResources { setupProcessResources(processToolsResources, toolsReplaceResources, compileToolsJava) }
processDatagenmainResources { dependsOn(compileJava) }
processDatagenadditionsResources { dependsOn(compileAdditionsJava) }
processDatagendefenseResources { dependsOn(compileDefenseJava) }
processDatagengeneratorsResources { dependsOn(compileGeneratorsJava) }
processDatagentoolsResources { dependsOn(compileToolsJava) }

def setupProcessResources(ProcessResources process, TaskProvider<Task> replaceResources, JavaCompile compileTask) {
    process.duplicatesStrategy(DuplicatesStrategy.FAIL)
    process.exclude('META-INF/mods.toml')
    process.from("${projectDir}") { include 'logo.png' }
    process.configure {
        //Depend on the compile task so that we can map the computer methods as needed
        dependsOn(compileTask)
        finalizedBy(replaceResources)
    }
    process.doLast {
        fileTree(dir: process.getOutputs().getFiles().getAsPath(), includes: jsonPatterns).each {
            File file -> file.setText(JsonOutput.toJson(new JsonSlurper().parse(file)))
        }
    }
}

//Make the various classes tasks depend on the corresponding replaceResources tasks in addition to the default processResources tasks they depend on
classes.configure { dependsOn(mainReplaceResources) }
additionsClasses.configure { dependsOn(additionsReplaceResources) }
defenseClasses.configure { dependsOn(defenseReplaceResources) }
generatorsClasses.configure { dependsOn(generatorsReplaceResources) }
toolsClasses.configure { dependsOn(toolsReplaceResources) }

def getManifestAttributes(String title) {
    return [
            "Specification-Title"     : title,
            "Specification-Vendor"    : "Mekanism",
            "Specification-Version"   : "${project.mod_version}",
            "Implementation-Title"    : title,
            "Implementation-Version"  : "${project.mod_version}",
            "Implementation-Vendor"   : "Mekanism",
            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
            "Automatic-Module-Name"   : title.toLowerCase(Locale.ROOT)
    ]
}

jar {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    from([sourceSets.api.output, sourceSets.main.output])
    manifest.attributes(getManifestAttributes("Mekanism"))
    afterEvaluate { finalizedBy reobfJar }
}

task sourcesJar(type: Jar, dependsOn: [classes, apiClasses, additionsClasses, defenseClasses, generatorsClasses, toolsClasses]) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveClassifier.set("sources")
    from(sourceSets.api.allJava, sourceSets.main.allJava, sourceSets.additions.allJava, sourceSets.defense.allJava, sourceSets.generators.allJava, sourceSets.tools.allJava)
    manifest.attributes(getManifestAttributes("Mekanism"))
}

task apiJar(type: Jar) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveClassifier.set("api")
    from sourceSets.api.output
    manifest.attributes(getManifestAttributes("Mekanism"))
    afterEvaluate { finalizedBy reobfApiJar }
}

task additionsJar(type: Jar) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveFileName.set("MekanismAdditions-${project.version}.jar")
    archiveClassifier.set("additions")
    from sourceSets.additions.output
    manifest.attributes(getManifestAttributes("MekanismAdditions"))
    afterEvaluate { finalizedBy reobfAdditionsJar }
}

task defenseJar(type: Jar) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveFileName.set("MekanismDefense-${project.version}.jar")
    archiveClassifier.set("defense")
    from sourceSets.defense.output
    manifest.attributes(getManifestAttributes("MekanismDefense"))
    afterEvaluate { finalizedBy reobfDefenseJar }
}

task generatorsJar(type: Jar) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveFileName.set("MekanismGenerators-${project.version}.jar")
    archiveClassifier.set("generators")
    from sourceSets.generators.output
    manifest.attributes(getManifestAttributes("MekanismGenerators"))
    afterEvaluate { finalizedBy reobfGeneratorsJar }
}

task toolsJar(type: Jar) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveFileName.set("MekanismTools-${project.version}.jar")
    archiveClassifier.set("tools")
    from sourceSets.tools.output
    manifest.attributes(getManifestAttributes("MekanismTools"))
    afterEvaluate { finalizedBy reobfToolsJar }
}

task allJar(type: Jar, dependsOn: [classes, apiClasses, additionsClasses, defenseClasses, generatorsClasses, toolsClasses]) {
    mustRunAfter(clean)
    afterEvaluate { finalizedBy reobfAllJar }
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveClassifier.set("all")
    manifest.attributes(getManifestAttributes("MekanismAll"))
    //Start by generating the merged data
    MergeJars.merge(project, sourceSets.main, sourceSets.additions, sourceSets.defense, sourceSets.generators, sourceSets.tools)
    //Then copy all the files except for ones we are going to include from the merged
    from(sourceSets.api.output)
    List<String> baseExcludeData = MergeJars.getGeneralPathsToExclude(project)
    Closure excludeFromMain = MergeJars.createExcludeClosure(baseExcludeData)
    from(sourceSets.main.output, excludeFromMain)
    Closure excludeFromAll = MergeJars.createExcludeClosure(baseExcludeData, 'logo.png', 'pack.mcmeta')
    from(sourceSets.additions.output, excludeFromAll)
    from(sourceSets.defense.output, excludeFromAll)
    from(sourceSets.generators.output, excludeFromAll)
    from(sourceSets.tools.output, excludeFromAll)
    //And finally copy over the generated files
    MergeJars.getGeneratedClosures(versionProperties).each { closure -> from("$buildDir/generated", closure) }
}

clean {
    //TODO: Try to come up with a slightly better solution to this that deletes more,
    // for example make it calculate the current hash and only leave that or only do
    // this if clean build is being ran. We also ideally would have it remove some of
    // the data from our generated folder, but for now this will do given jenkins runs
    // a clean build because we need to make sure it doesn't fail
    def filteredDelete = new HashSet<>()
    for (def toDelete : getDelete()) {
        for (def f : file(toDelete).listFiles()) {
            if (f.getName() != "fg_cache") {
                if (f.getName() == "generated") {
                    for (def generated : file(f).listFiles()) {
                        if (generated.getName() != "data" && generated.getName() != "META-INF") {
                            filteredDelete.add(generated)
                        }
                    }
                } else {
                    filteredDelete.add(f)
                }
            }
        }
    }
    setDelete(filteredDelete)
}

tasks.withType(JavaCompile).configureEach({
    it.options.encoding = 'UTF-8'
    it.options.compilerArgs << "-Xmaxerrs" << "100000"
})

//Configure specific compile tasks to have the proper annotation processor info
compileJava { setupCompileJava(compileJava, "main", "mekanism") }
compileAdditionsJava { setupCompileJava(compileAdditionsJava, "additions", "mekanismadditions") }
compileDefenseJava { setupCompileJava(compileDefenseJava, "defense", "mekanismdefense") }
compileGeneratorsJava { setupCompileJava(compileGeneratorsJava, "generators", "mekanismgenerators") }
compileToolsJava { setupCompileJava(compileToolsJava, "tools", "mekanismtools") }

def setupCompileJava(JavaCompile task, String baseFolder, String module) {
    task.options.annotationProcessorPath = configurations.annotationProcessor
    task.options.getGeneratedSourceOutputDirectory().set(file("src/datagen/${baseFolder}/"))
    task.options.compilerArgs = [
            "-processor", "mekanism.ParamNameMapper",
            "-AmekanismModule=${module}"
    ]
}

artifacts {
    archives apiJar
    archives jar
    archives additionsJar
    archives generatorsJar
    archives defenseJar
    archives toolsJar
    archives allJar
    archives sourcesJar
}

reobf {
    apiJar { classpath.from(sourceSets.api.compileClasspath) }
    jar { classpath.from(sourceSets.main.compileClasspath) }
    additionsJar { classpath.from(sourceSets.additions.compileClasspath) }
    generatorsJar { classpath.from(sourceSets.generators.compileClasspath) }
    defenseJar { classpath.from(sourceSets.defense.compileClasspath) }
    toolsJar { classpath.from(sourceSets.tools.compileClasspath) }
    allJar {}
}

//Minimize/optimize all png files, requires optipng on the PATH
// Credits: BrainStone
void minimizePNGFile(File file) {
    long size = file.length()
    exec {
        executable "optipng"
        args "-q", "-o7", "-zm1-9", "-strip", "all", file
    }
    long newSize = file.length()
    if (newSize < size) {
        System.out.format("Reduced File size of %s from %d bytes to %d bytes (reduced by %.2f%%)\n",
                file, size, newSize, ((double) (size - newSize)) / ((double) size) * 100.0)
    }
}

task optimizePng {
    def pngPatterns = ["**/*.png"]
    doLast {
        //Ensure the logo is minimized (we add this file to each jar)
        minimizePNGFile(file("${projectDir}/logo.png"))
        //Minimize any PNGs in the source sets
        def sourceSets = [sourceSets.main, sourceSets.additions, sourceSets.generators, sourceSets.defense, sourceSets.tools]
        for (def sourceSet : sourceSets) {
            for (dir in sourceSet.resources.srcDirs) {
                fileTree(dir: dir, includes: pngPatterns).each { minimizePNGFile(it) }
            }
        }
    }
}

tasks.withType(GenerateModuleMetadata) {
    //Disable Gradle 7 module metadata generation as it does not play nicely with FG
    enabled = false
}

//properties to put in $HOME/.gradle/gradle.properties
def MAVEN_PASSWORD_PROPERTY_NAME = 'mekanismMavenPassword'

publishing {
    publications { PublicationContainer publicationContainer ->
        publicationContainer.register("maven", MavenPublication) { MavenPublication publication ->
            publication.from((SoftwareComponent) components.java)
            publication.groupId = project.group
            publication.version = project.version
            publication.artifactId = System.getenv("MAVEN_ARTIFACT") ?: project.archivesBaseName
            publication.artifacts = [apiJar, jar, generatorsJar, additionsJar, toolsJar, allJar, sourcesJar]
            publication.pom {
                name.set("Mekanism")
                packaging = 'jar'
                description.set('Mekanism is a Minecraft add-on featuring high-tech machinery that can be used to create powerful tools, armor, and weapons.')
                url.set('https://aidancbrady.com/mekanism/')
                scm {
                    url.set('https://github.com/mekanism/Mekanism.git')
                }
                issueManagement {
                    system.set('github')
                    url.set('https://github.com/mekanism/Mekanism/issues')
                }
                licenses {
                    license {
                        name.set('MIT')
                        distribution.set('repo')
                    }
                }
                withXml {
                    NodeList dependencies = asNode().dependencies
                    NodeList allDeps = dependencies.'*'

                    // Remove forge deps
                    allDeps.<Node> findAll() { Node el ->
                        el.artifactId.text() == 'forge' && el.groupId.text() == 'net.minecraftforge'
                    }.forEach() { Node el ->
                        el.parent().remove(el)
                    }
                    //remove ForgeGradle's mapped suffix from versions & set as optional so anyone else doesn't inherit them
                    allDeps.<Node> findAll() { Node el ->
                        el.version.text().contains('_mapped_')
                    }.each { Node el ->
                        el.version.each { Node version ->
                            def versionText = version.text()
                            version.setValue(versionText.substring(0, versionText.indexOf('_mapped_')))
                        }
                        el.appendNode('optional', true)
                    }
                }
            }
        }
    }
    repositories {
        maven {
            url = 'https://modmaven.dev/artifactory/local-releases/'
            if (project.findProperty(MAVEN_PASSWORD_PROPERTY_NAME) != null) {
                credentials {
                    username = "mekanism"
                    password = project.findProperty(MAVEN_PASSWORD_PROPERTY_NAME)
                }
            }
        }
    }
}

def resolvedChangelog = null

//closure to generate the changelog once, and only when needed by CurseGradle or Modrinth
def changeLogResolver = { ->
    if (resolvedChangelog != null) {
        println "Using cached changelog"
        return resolvedChangelog
    }
    def generatedChangelog = "Unable to generate changelog :("
    def currentCommit = System.getenv("GIT_COMMIT")
    def prevCommit = System.getenv("GIT_PREVIOUS_SUCCESSFUL_COMMIT") ?: System.getenv("GIT_PREVIOUS_COMMIT")

    if (currentCommit != null && prevCommit != null) {
        generatedChangelog = ""
        grgit.log {
            range(prevCommit, currentCommit)
        }.reverse().each { commit ->
            //Use full message rather than short message to get any new lines, and trim it so that any trailing new lines
            // get removed so that we don't end up with extra spaces
            String message = commit.fullMessage.trim()
            if (!message.startsWith("Merge branch") && !message.startsWith("Merge pull request")) {
                //Ignore Merges and PR Merges
                message = message.replaceAll("#(\\d+)", { match ->//turn issues/prs into links (github currently supports prs being linked as issues)
                    return "<a href=\"https://github.com/mekanism/Mekanism/issues/${match[1]}\">${match[0]}</a>"
                }).replaceAll("\\n", "<br>&emsp;")//convert new lines that are part of a commit message into actual new lines and a tab
                if (generatedChangelog != "") {
                    //If this isn't the first commit prepend an extra newline
                    generatedChangelog += "<br>"
                }
                generatedChangelog += "<a href=\"https://github.com/mekanism/Mekanism/commit/${commit.id}\">${commit.getAbbreviatedId()}</a> - ${message}"
            }
        }
        println "Changelog generated"
    }

    def releaseNotesFile = project.file("docs/release_${mod_version}.html")
    if (releaseNotesFile.exists()) {
        //Add any version specific changelog stuff
        def releaseNotes = releaseNotesFile.getText()
        generatedChangelog = "$releaseNotes<br> $generatedChangelog"
    }

    if (release_type == "alpha") {
        //Add a warning at the top about what an alpha build means
        generatedChangelog = "Warning: Mekanism is currently in alpha, and is not recommended for widespread use in modpacks. There are likely to be game breaking bugs, " +
                "and updating from one alpha to the next may cause various mekanism blocks to disappear/void their contents. While we will try to not have this happen/keep " +
                "it to a minimum make sure to make backups. You can read more about the alpha state of this project <a href=\"https://github.com/mekanism/Mekanism#alpha-status\">here</a>." +
                "<br> $generatedChangelog"
    }
    resolvedChangelog = generatedChangelog
    return generatedChangelog
}

if (System.getenv("CURSEFORGE_KEY") != null || project.hasProperty('curseforgeKey')) {
    println "Enabling Curseforge config"
    tasks.curseforge.dependsOn(jar, additionsJar, generatorsJar, /*defenseJar,*/ toolsJar, apiJar)
    curseforge {
        apiKey = System.getenv("CURSEFORGE_KEY") ?: project.findProperty("curseforgeKey")

        //Main
        project {
            id = '268560'
            changelogType = "html"
            changelog = changeLogResolver
            releaseType = "${release_type}"
            mainArtifact(jar) {
                relations {
                    optionalDependency "applied-energistics-2"
                    optionalDependency "biomes-o-plenty"
                    optionalDependency "cc-tweaked"
                    optionalDependency "crafttweaker"
                    optionalDependency "ctm"
                    optionalDependency "curios"
                    optionalDependency "female-gender-forge"
                    //optionalDependency "flux-networks"
                    optionalDependency "i-like-wood"
                    optionalDependency "i-like-wood-biomes-o-plenty-plugin"
                    optionalDependency "i-like-wood-oh-the-biomes-youll-go-plugin"
                    optionalDependency "jade"
                    optionalDependency "jei"
                    optionalDependency "jeitweaker"
                    optionalDependency "oc2"
                    optionalDependency "oh-the-biomes-youll-go"
                    optionalDependency "perviaminvenire"
                    optionalDependency "projecte"
                    optionalDependency "the-one-probe"
                }
            }
            addArtifact apiJar
            addGameVersion "Java ${java_version}"
            addGameVersion "${minecraft_version}"
        }

        //Additions
        project {
            id = '345425'
            changelogType = "html"
            changelog = changeLogResolver
            releaseType = "${release_type}"
            mainArtifact(additionsJar) {
                relations {
                    requiredDependency "mekanism"
                }
            }
            addGameVersion "Java ${java_version}"
            addGameVersion "${minecraft_version}"
        }

        //Defense
        /*project {
            id = '376939'
            changelogType = "html"
            changelog = changeLogResolver
            releaseType = "${release_type}"
            mainArtifact(defenseJar) {
                relations {
                    requiredDependency "mekanism"
                }
            }
            addGameVersion "Java ${java_version}"
            addGameVersion "${minecraft_version}"
        }*/

        //Generators
        project {
            id = '268566'
            changelogType = "html"
            changelog = changeLogResolver
            releaseType = "${release_type}"
            mainArtifact(generatorsJar) {
                relations {
                    requiredDependency "mekanism"
                }
            }
            addGameVersion "Java ${java_version}"
            addGameVersion "${minecraft_version}"
        }

        //Tools
        project {
            id = '268567'
            changelogType = "html"
            changelog = changeLogResolver
            releaseType = "${release_type}"
            mainArtifact(toolsJar) {
                relations {
                    requiredDependency "mekanism"
                }
            }
            addGameVersion "Java ${java_version}"
            addGameVersion "${minecraft_version}"
        }
    }
}

if (System.getenv("MODRINTH_TOKEN") != null || project.hasProperty('modrinthToken')) {
    println "Enabling Modrinth config"
    def additionsModrinth = createSecondaryModrinthUpload("additions", "a6F3uASn", additionsJar)
    //def defenseModrinth = createSecondaryModrinthUpload("defense", "", defenseJar)
    def generatorsModrinth = createSecondaryModrinthUpload("generators", "OFVYKsAk", generatorsJar)
    def toolsModrinth = createSecondaryModrinthUpload("tools", "tqQpq1lt", toolsJar)
    tasks.modrinth {
        dependsOn(jar, apiJar)
        finalizedBy(additionsModrinth, generatorsModrinth, toolsModrinth)
    }

    modrinth {
        token = System.getenv("MODRINTH_TOKEN") ?: project.findProperty("modrinthToken")
        projectId = "Ce6I4WUE"
        //Use the full "basic" version number rather than just mod version number so that if multiple releases end up happening due to bugs
        // then we don't run into conflicts in uploading
        //Note: The versionName is set to the versionNumber automatically
        versionNumber = "${basicVersion}"
        versionType = "${release_type}"
        changelog = changeLogResolver.call()
        uploadFile = jar
        additionalFiles = [apiJar]
        gameVersions = ["${minecraft_version}"]
        //Note: Can't use nested dependency configuration as we have no way to clear it for the secondary uploads
        dependencies = [
                new ModDependency("XxWD5pD3", "optional"),//AE2
                new ModDependency("gu7yAYhd", "optional"),//CC: Tweaked
                new ModDependency("uE1WpIAk", "optional"),//Oh the Biomes You'll Go
                new ModDependency("bcOsQHnC", "optional"),//Wildfire's Female Gender Mod
        ]
    }
}

def createSecondaryModrinthUpload(String output, String targetProjectId, Jar sourceSetJar) {
    return tasks.register("${output}Modrinth", TaskModrinthUpload, it -> {
        it.setGroup("publishing")
        it.setDescription("Upload Mekanism ${output} to Modrinth")
        it.dependsOn(tasks.named("modrinth"), sourceSetJar)
        it.doFirst {
            //Run in do first to change the configured extension values before it starts applying
            modrinth {
                projectId = targetProjectId
                uploadFile = sourceSetJar
                //Clear additional upload files as this is a modification of what things are set to from before
                additionalFiles = []
                //Mark that the addon requires the build of Mekanism that we just uploaded (and override it to clear all optional dependencies)
                if (tasks.modrinth.uploadInfo == null || tasks.modrinth.uploadInfo.id == null) {
                    //If we failed to find the upload version just set it to Mekanism in general
                    dependencies = [new ModDependency("Ce6I4WUE", "required")]
                } else {
                    dependencies = [new VersionDependency(tasks.modrinth.uploadInfo.id, "required")]
                }
            }
            println "Updated Modrinth extension"
        }
    })
}