common.gradle

import com.google.common.collect.ImmutableList
import com.google.common.collect.ImmutableMap
import net.fabricmc.loom.util.Platform
import org.objectweb.asm.ClassReader
import org.objectweb.asm.ClassWriter
import org.objectweb.asm.tree.ClassNode
import org.objectweb.asm.tree.LdcInsnNode

apply(plugin: "fabric-loom")
apply(plugin: "maven-publish")
apply(plugin: "com.replaymod.preprocess")

int mcVersion = 1

preprocess {
    mcVersion = vars.get().get("MC")
    tabIndentation.set(false)
}

repositories {
    mavenLocal()

    maven {
        name("Curse Maven")
        url("https://www.cursemaven.com")

        content {
            includeGroup("curse.maven")
        }
    }

    maven {
        name("Modrinth Maven")
        url("https://api.modrinth.com/maven")

        content {
            includeGroup("maven.modrinth")
        }
    }

    maven {
        name("Jitpack Maven")
        url("https://jitpack.io")

        content {
            includeGroup("com.github.Nyan-Work")
            includeGroup("com.github.gnembon")
        }
    }

    mavenCentral()
}

configurations {
    register("productionRuntimeClient") {configuration ->
        configurations.findAll { it.name in [
                "minecraftLibraries",
                "loaderLibraries",
                "minecraftRuntimeLibraries"
        ]}.forEach { Configuration superConfigurations ->
            configuration.extendsFrom(superConfigurations)
        }
    }

    register("productionRuntimeServer")
    register("productionRuntimeMods")
}

// Module, Property prefix, Resolve condition, Transitive dependencies.
def compileOnlyDependencies = [
        ["curse.maven:litematica-308892"        , "litematica"        , true             , false],
        ["curse.maven:not-enough-crashes-353890", "not_enough_crashes", true             , false],
        ["com.github.gnembon:fabric-carpet"     , "fabric_carpet"     , mcVersion > 12001, false],
]

dependencies {
    // Development environment
    minecraft("com.mojang:minecraft:${project.minecraft_version}")
    mappings(loom.officialMojangMappings())

    // Annotation processor
    modCompileOnly("org.projectlombok:lombok:${project.lombok_version}")
    annotationProcessor("org.projectlombok:lombok:${project.lombok_version}")

    // Dependency
    modImplementation("top.hendrixshen.magiclib:magiclib-${project.minecraft_version.replace(".", "_")}:${project.magiclib_version}") {
        if (project.isCIEnvironment()) {
            exclude(group: "net.fabricmc.fabric-api", module: "fabric-api")
        }

        exclude(group: "carpet", module: "fabric-carpet")
    }

    productionRuntimeMods("top.hendrixshen:magiclib-${project.minecraft_version.replace(".", "_")}:${project.magiclib_version}")

    // Compile only library.
    compileOnlyDependencies.forEach {item ->
        String dependencyNotation = item[0]
        String propertyPrefix = item[1]
        boolean shouldResolve = item[2]
        boolean shouldTransitive = item[3]

        if (shouldResolve) {
            modCompileOnly("${dependencyNotation}:${project.property("${propertyPrefix}_version")}") {
                transitive(shouldTransitive)
            }
        }
    }

    // ProductionRuntime Environment
    productionRuntimeClient("net.fabricmc:fabric-loader:${project.fabric_loader_version}")
    productionRuntimeClient("net.fabricmc:intermediary:${project.minecraft_version}")

    productionRuntimeServer("net.fabricmc:fabric-installer:${project.fabric_installer_version}:server")

    runtimeOnly(project(path: ":fabricWrapper"))
}

group(project.mod_maven_group)
version(project.parent.version)

base {
    archivesName.set("${project.mod_archives_base_name}-${project.minecraft_version}")
}

loom {
    interfaceInjection {
        enableDependencyInterfaceInjection.set(true)
    }

    runConfigs.configureEach {
        // Dump modified classes automatically.
        property("mixin.debug.export", "true")
    }

    runConfigs.named("client") {
        programArgs([
                "--width",
                "1920",
                "--height",
                "1080",
        ])
        runDir("run/client")
    }

    runConfigs.named("server") {
        runDir("run/server")
    }

    runs {
        mixinAuditClient {
            inherit(client)
            vmArgs("-Dmagiclib.mixin_audit=true")
            ideConfigGenerated(false)
            runDir("run/client")
        }

        mixinAuditServer {
            inherit(server)
            vmArgs("-Dmagiclib.mixin_audit=true")
            ideConfigGenerated(false)
            runDir("run/server")
        }
    }

    // Setup client default settings.
    runClient {
        defaultCharacterEncoding("UTF-8")

        if (!new File("${projectDir}/run/client/options.txt").exists()) {
            new File("${projectDir}/run/client").mkdirs()
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("${projectDir}/run/client/options.txt"))
            bufferedWriter.writeLine("autoJump:false")
            bufferedWriter.writeLine("enableVsync:false")
            bufferedWriter.writeLine("forceUnicodeFont:true")
            bufferedWriter.writeLine("fov:1.0")
            bufferedWriter.writeLine("gamma:16.0")
            bufferedWriter.writeLine("guiScale:3")
            bufferedWriter.writeLine("lang:${Locale.getDefault().toString()}")
            bufferedWriter.writeLine("maxFps:260")
            bufferedWriter.writeLine("renderDistance:10")
            bufferedWriter.writeLine("soundCategory_master:0.0")
            bufferedWriter.close()
        }
    }

    // Setup server default settings.
    runServer {
        defaultCharacterEncoding("UTF-8")

        // Agree eula before server init.
        if (!new File("${projectDir}/run/server/eula.txt").exists()) {
            new File("${projectDir}/run/server").mkdirs()
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("${projectDir}/run/server/eula.txt"))
            bufferedWriter.writeLine("eula=true")
            bufferedWriter.close()
        }
    }
}

tasks.register("serverPropertiesJar", Jar) {
    File propsFile = file("build/tmp/install.properties")

    doFirst {
        if (propsFile.exists()) {
            propsFile.delete()
        }

        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(propsFile))
        bufferedWriter.writeLine("fabric-loader-version=${project.fabric_loader_version}")
        bufferedWriter.writeLine("game-version=${project.minecraft_version}")
        bufferedWriter.close()
    }

    archiveFileName.set("server-properties.jar")
    destinationDirectory.set(file("build/tmp"))
    from(propsFile)
}

tasks.register("runProductionClient", JavaExec) {
    dependsOn(tasks.remapJar)
    classpath.from(configurations.productionRuntimeClient)
    mainClass.set("net.fabricmc.loader.impl.launch.knot.KnotClient")
    workingDir(file("run/client"))

    doFirst {
        classpath.from(loom.minecraftProvider.minecraftClientJar)
        args(
                "--assetIndex", loom.minecraftProvider.versionInfo.assetIndex().fabricId(loom.minecraftProvider.minecraftVersion()),
                "--assetsDir", file("${loom.files.userCache}/assets").absolutePath,
                "--gameDir", workingDir.absolutePath,
                "--width", "1920",
                "--height", "1080"
        )
        jvmArgs("-Dmixin.debug.export=true")
        jvmArgs("-Dfabric.addMods=${configurations.productionRuntimeMods.files.join(File.pathSeparator)}${File.pathSeparator}${tasks.remapJar.archiveFile.get().asFile.absolutePath}")


        if (Platform.CURRENT.operatingSystem.isMacOS()) {
            jvmArgs("-XstartOnFirstThread")
        }
    }
}

tasks.register("runProductionServer", JavaExec) {
    dependsOn(tasks.remapJar)
    classpath.from(configurations.productionRuntimeServer, tasks.named("serverPropertiesJar"))
    mainClass.set("net.fabricmc.installer.ServerLauncher")
    workingDir(file("run/server"))

    doFirst {
        args("nogui")
        jvmArgs("-Dmixin.debug.export=true")
        jvmArgs("-Dfabric.addMods=${configurations.productionRuntimeMods.files.join(File.pathSeparator)}${File.pathSeparator}${tasks.remapJar.archiveFile.get().asFile.absolutePath}")
    }
}

["serverPropertiesJar",
 "runClient"          , "runServer",
 "runMixinAuditClient", "runMixinAuditServer",
 "runProductionClient", "runProductionServer",
 "preprocessCode"     , "preprocessResources",
 "preprocessTestCode" , "preprocessTestResources"].forEach {
    if (tasks.getNames().contains(it)) {
        tasks.named(it) {
            it.group("${mod_id}")
        }
    }
}

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

remapJar {
    remapperIsolation.set(true)
}

processResources {
    outputs.upToDateWhen { false }

    from("${rootDir}/LICENSE")

    from("${rootDir}/icon.png") {
        into("assets/${project.mod_id}")
    }

    filesMatching("fabric.mod.json") {
        filter { line ->
            line.trim().startsWith("//") ? null : line
        }

        expand([
                "magiclib_dependency" : project.magiclib_dependency,
                "minecraft_dependency": project.minecraft_dependency,
                "minecraft_version_id": project.minecraft_version.replace(".", "_"),
                "minecraft_version"   : project.minecraft_version,
                "mod_description"     : project.mod_description,
                "mod_homepage"        : project.mod_homepage,
                "mod_id"              : project.mod_id,
                "mod_license"         : project.mod_license,
                "mod_name"            : project.mod_name,
                "mod_sources"         : project.mod_sources,
                "mod_version"         : project.version
        ])
    }
}

java {
    if (mcVersion > 11701) {
        sourceCompatibility(JavaVersion.VERSION_16)
        targetCompatibility(JavaVersion.VERSION_16)
    } else {
        sourceCompatibility(JavaVersion.VERSION_1_8)
        targetCompatibility(JavaVersion.VERSION_1_8)
    }

    withSourcesJar()
}

publishing {
    publications {
        register("mavenJava", MavenPublication) {
            artifactId("${project.mod_id}-${project.minecraft_version.replace(".", "_")}")
            version("${rootProject.getMavenArtifactVersion()}")
            from(components.java)
        }
    }

    repositories {
        mavenLocal()

        maven {
            url("$rootDir/publish")
        }
    }
}

ImmutableMap<Object, Object> replaceTokenMap = ImmutableMap.builder()
        .put("@MOD_IDENTIFIER@"            , project.mod_id)
        .put("@MOD_NAME@"                  , project.mod_name)
        .put("@MINECRAFT_VERSION_IDENTIFY@", project.minecraft_version.replace(".", "_"))
        .build()
ImmutableList<Object> replaceTokenFile = ImmutableList.builder()
        .add("TweakMyClientReference")
        .build()

tasks.classes {
    doLast {
        File dir = file("build/classes/java")

        dir.eachFileRecurse {
            String path = it.path.replace(dir.path, "")

            if (path.endsWith(".class") && replaceTokenFile.stream().anyMatch { path.contains(it as String) }) {
                ClassReader cr = new ClassReader(it.newInputStream().bytes)
                ClassNode cn = new ClassNode()
                cr.accept(cn, ClassReader.SKIP_FRAMES | ClassReader.SKIP_DEBUG)

                // ReplaceToken in fields
                cn.fields.each {
                    if (it.desc == "Ljava/lang/String;" && it.value instanceof String) {
                        String value = it.value as String

                        replaceTokenMap.each {
                            value = value.replace(it.key as String, it.value as String)
                        }

                        it.value = value
                    }
                }

                // ReplaceToken in methods
                cn.methods.each {
                    it.instructions.each {
                        if (it instanceof LdcInsnNode) {
                            LdcInsnNode ldc = it as LdcInsnNode

                            if (ldc.cst instanceof String) {
                                String value = ldc.cst as String

                                replaceTokenMap.each {
                                    value = value.replace(it.key as String, it.value as String)
                                }

                                ldc.cst = value
                            }
                        }
                    }
                }

                ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES)
                cn.accept(cw)
                new FileOutputStream(it).write(cw.toByteArray())
            }
        }
    }
}