common.gradle

buildscript {
    dependencies {
        classpath 'org.kohsuke:github-api:1.114'
    }

    repositories {
        gradlePluginPortal()
    }
}

version = project.mod_version
group = project.maven_group
def local_wunderlib = findProject(':wunderlib') != null


allprojects { projIt ->
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'eclipse'
    apply plugin: 'maven-publish'
    apply plugin: 'fabric-loom'

    repositories {
        maven { url "https://maven.dblsaiko.net/" }
        maven { url "https://maven.fabricmc.net/" }
        maven { url "https://maven.shedaniel.me/" }
        maven { url 'https://maven.blamejared.com' }
        maven { url 'https://jitpack.io' }
        maven { url 'https://maven.terraformersmc.com/releases' }
        maven { url 'https://maven.terraformersmc.com' }
        maven { url 'https://maven.ambertation.de/releases' }
    }

    version = rootProject.mod_version
    group = rootProject.maven_group


    java {
        // Must be added before the split source sets are setup.
        withSourcesJar()
    }

    sourceSets {
        main {
            resources {
                srcDirs += [
                        'src/main/generated'
                ]
            }
            java {
                srcDirs += ['src/client/java', 'src/datagen/java']
            }
        }

        testmod {
            resources {
                srcDirs += [
                        'src/testmod/generated'
                ]
            }
            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath
        }

        testmodClient {
            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath

            compileClasspath += testmod.compileClasspath
            runtimeClasspath += testmod.runtimeClasspath
        }

        testmodDatagen {
            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath

            compileClasspath += testmod.compileClasspath
            runtimeClasspath += testmod.runtimeClasspath
            compileClasspath += testmodClient.compileClasspath
            runtimeClasspath += testmodClient.runtimeClasspath
        }
    }

    loom {

        //runtimeOnlyLog4j = true
        runs {
            testmodClient {
                client()
                ideConfigGenerated project.rootProject == project
                name = "Testmod Client"
                source sourceSets.testmodClient
            }
            testmodServer {
                server()
                ideConfigGenerated project.rootProject == project
                name = "Testmod Server"
                runDir "run-server"
                source sourceSets.testmod
            }
            if (project.rootProject != project) {
                println "${projIt.name}-testmod"

                if (projIt.file('src/testmod').exists()) {
                    "${projIt.name}-testmod" {
                        server()
                        runDir "run-server"
                        name = "Testmod - ${projIt.name}"
                        ideConfigGenerated true
                        //source sourceSets["${projIt.name}-testmod"]
                        source sourceSets.testmod
                    }
                }

                if (projIt.file('src/testmodClient').exists()) {
                    "${projIt.name}-testmodClient" {
                        client()
                        runDir "run"
                        name = "Testmod Client - ${projIt.name}"
                        ideConfigGenerated true
                        //source sourceSets["${projIt.name}-testmodClient"]
                        source sourceSets.testmodClient
                    }
                }


                if (projIt.file('src/testmodDatagen').exists()) {
                    def modId = projIt.name.replace('-api', '-testmod');
                    "${projIt.name}-testmodDatagen" {
                        client()
                        vmArg "-Dfabric-api.datagen"
                        vmArg "-Dfabric-api.datagen.output-dir=${file("src/testmod/generated")}"
                        vmArg "-Dfabric-api.datagen.modid=${modId}"

                        runDir "build/datagenTestmod"
                        name = "Testmod DataGen - ${projIt.name}"
                        ideConfigGenerated true
                        source sourceSets.testmodDatagen
                    }
                }

                if (projIt.file('src/datagen').exists()) {
                    def modId = projIt.name.replace('-api', '');
                    println("Mod ID: ${modId}")
                    "${projIt.name}-datagen" {
                        client()
                        vmArg "-Dfabric-api.datagen"
                        vmArg "-Dfabric-api.datagen.output-dir=${file("src/main/generated")}"
                        vmArg "-Dfabric-api.datagen.modid=${modId}"

                        runDir "build/datagen"
                        name = "DataGen - ${projIt.name}"
                        ideConfigGenerated true
                    }
                }
            }
        }
    }

    configurations {
        dev {
            transitive true
            canBeResolved = true
            canBeConsumed = true
            extendsFrom api
        }
        localDev {
            extendsFrom dev
        }
    }

    dependencies {
        println("Adding dependencies for ${projIt.name}")
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings loom.officialMojangMappings()
        modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

        dev sourceSets.main.output

        testmodImplementation sourceSets.main.output
        testmodClientImplementation sourceSets.main.output
        testmodClientImplementation sourceSets.testmod.output

        testmodDatagenImplementation sourceSets.main.output
        testmodDatagenImplementation sourceSets.testmod.output
        testmodDatagenImplementation sourceSets.testmodClient.output

        if (projIt.name != "wunderlib") {
            if (local_wunderlib) {
                implementation project(path: ":wunderlib", configuration: 'dev')
            } else {
                modApi "de.ambertation:wunderlib:${project.wunderlib_version}"
            }
        }
    }

    processResources {
        println "Version: ${project.mod_version}"
        inputs.property "version", project.mod_version

        filesMatching("fabric.mod.json") {
            expand "version": project.mod_version
        }
    }

    // ensure that the encoding is set to UTF-8, no matter what the system default is
    // this fixes some edge cases with special characters not displaying correctly
    // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
    tasks.withType(JavaCompile) {
        options.encoding = "UTF-8"
        it.options.release = 21
    }

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

    // Run this task after updating minecraft to regenerate any required resources
    tasks.register('generateResources') {
        group = "fabric"
    }

    tasks.register('testmodJar', Jar) {
        from sourceSets.testmod.output
        from sourceSets.testmodClient.output
        from sourceSets.testmodDatagen.output
        destinationDirectory = new File(project.buildDir, "devlibs")
        archiveClassifier = "testmod"
    }

    [jar, sourcesJar].each {
        it.from(rootProject.file("LICENSE")) {
            rename { "${it}-${project.base.archivesName.get()}" }
        }
    }
}

allprojects.each { p ->
    loom.mods.register(p.name) {
        sourceSet p.sourceSets.main
    }

    loom.mods.register(p.name + "-testmod") {
        sourceSet p.sourceSets.testmod
        sourceSet p.sourceSets.testmodClient
        sourceSet p.sourceSets.testmodDatagen
    }
}

subprojects.each {
    remapJar.dependsOn("${it.path}:remapJar")
}

tasks.sourcesJar {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}


//dependencies for the main Libraray
dependencies {
    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"

    subprojects.each {
        api project(path: "${it.path}", configuration: "namedElements")

//        testmodImplementation project("${it.path}").sourceSets.testmod.output
//        testmodClientImplementation project("${it.path}").sourceSets.testmodClient.output
//        testmodClientImplementation project("${it.path}").sourceSets.client.output
//
//        testmodDatagenImplementation project("${it.path}").sourceSets.testmodDatagen.output

        include project("${it.path}")
    }
    modCompileOnly "com.terraformersmc:modmenu:${project.modmenu_version}"
    modLocalRuntime "com.terraformersmc:modmenu:${project.modmenu_version}"

    if (local_wunderlib) {
        implementation project(path: ":wunderlib", configuration: 'dev')
        include project(path: ":wunderlib")
    } else {
        modApi "de.ambertation:wunderlib:${project.wunderlib_version}"
        include "de.ambertation:wunderlib:${project.wunderlib_version}"
    }
}

loom {
    runs {
        datagen {
            inherit client
            name "Data Generation"
            vmArg "-Dfabric-api.datagen"
            vmArg "-Dfabric-api.datagen.output-dir=${file("src/main/generated")}"
            vmArg "-Dfabric-api.datagen.modid=${project.archives_base_name}"

            runDir "build/datagen"
        }
    }

    subprojects.each { sub ->
        //println "${sub.loom.accessWidenerPath.text}"
        try {

        } catch (e) {
            println "No access widener for ${sub.name}"
        }

    }
    accessWidenerPath = file("src/main/resources/wover.accesswidener")

    enableTransitiveAccessWideners = true
}

task copyHighlightJs(type: Copy) {
    from 'javadoc/contrib' // Path to the local folder containing Highlight.js
    into "$buildDir/docs/javadoc/contrib" // Specify the destination folder in the generated Javadoc
}


javadoc {
    options {
        source = "17"
        encoding = "UTF-8"
        charSet = "UTF-8"
        memberLevel = JavadocMemberLevel.PROTECTED
        links("https://docs.oracle.com/en/java/javase/17/docs/api/")
        // Disable the crazy super-strict doclint tool in Java 8
        addStringOption("Xdoclint:none", "-quiet")
        addStringOption("noqualifier", "net.minecraft.*:com.mojang.*:net.fabricmc.*")
        addBooleanOption("-allow-script-in-comments", true)
        tags(
                'apiNote:a:API Note:',
                'implSpec:a:Implementation Requirements:',
                'implNote:a:Implementation Note:'
        )
        header = "<script type=\"text/javascript\" src=\"../../../../../contrib/highlight/highlight.min.js\"></script>" +
                " <link rel=\"stylesheet\" href=\"../../../../../contrib/highlight/styles/default.min.css\"></link>" +
                " <script>window.onload = function () {\n" +
                "    var allPre, i, j;\n" +
                "    allPre = document.getElementsByTagName(\"pre\");\n" +
                "    console.log(allPre); \n" +
                "    for (i = 0, j = allPre.length; i < j; i++) {\n" +
                "        hljs.highlightElement(allPre[i]);\n" +
                "    }\n" +
                "};</script>"

        stylesheetFile = file("javadoc/wover.css")
    }


    allprojects.each {
        source(it.sourceSets.main.allJava)
    }

    classpath = files(sourceSets.main.compileClasspath, sourceSets.main.runtimeClasspath)
    include("**/api/**")
    include("de/ambertation/**")
    include("org/betterx/wover/util/**")
    failOnError true

    finalizedBy copyHighlightJs
}

jar {
    from "LICENSE"
}

configurations {
    dev {
        canBeConsumed true
        canBeResolved true
    }
    localDev {
        extendsFrom dev
    }
}

task javadocJar(type: Jar, dependsOn: [javadoc, copyHighlightJs]) {
    archiveClassifier = 'javadoc'
    from javadoc.destinationDir
}

artifacts {
    dev remapJar
    localDev jar
    archives sourcesJar
    archives javadocJar
}

idea {
    module {
        excludeDirs += file('javadoc')
        excludeDirs += file('gradle')
        excludeDirs += file('public')
        excludeDirs += file('tools')
        excludeDirs += file('bin')
        subprojects.each {
            excludeDirs += it.file('run')
            excludeDirs += it.file('run-server')
        }
    }
}