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: "dev.architectury.loom")
apply(plugin: "maven-publish")
apply(plugin: "signing")
apply(plugin: "com.replaymod.preprocess")

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("Masa Maven")
        url("https://masa.dy.fi/maven")
    }

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

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

    mavenCentral()
}

int mcVersion = 1

preprocess {
    mcVersion = vars.get().get("MC")
    tabIndentation.set(false)
    patternAnnotation.set("top.hendrixshen.magiclib.compat.preprocess.api.annotation.Preprocess")
}

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 apiDependencies = [
        ["maven.modrinth:curtain"              , "curtain" , true, false],
        ["maven.modrinth:mafglib"              , "mafglib", true, false]
]

// Module, Property prefix, Resolve condition, Transitive dependencies.
def runtimeDependencies = [
        ["maven.modrinth:cloth-config"               , "cloth_config"           , mcVersion < 11600                     , false],
        ["maven.modrinth:in-game-account-switcher"   , "inGameAccountSwitcher"  , mcVersion < 12002                     , false],
        ["maven.modrinth:imblocker-original"         , "imblocker"              , mcVersion < 12002                     , false],
        ["curse.maven:smooth-boot-forge-420913"      , "smoothboot"             , mcVersion < 11802                     , false],
        ["maven.modrinth:smooth-boot-reloaded"       , "smoothbootreloaded"     , mcVersion > 11802 && mcVersion < 12002, false],
]

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

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

    // API
    apiDependencies.forEach {item ->
        String dependencyNotation = item[0]
        String propertyPrefix = item[1]
        boolean shouldResolve = item[2]
        boolean shouldTransitive = item[3]

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

            productionRuntimeMods("${dependencyNotation}:${project.property("${propertyPrefix}_version")}") {
                transitive(shouldTransitive)
            }
        }
    }

    // Runtime Library - Make development environment comfortable.
    runtimeDependencies.forEach {item ->
        String dependencyNotation = item[0]
        String propertyPrefix = item[1]
        boolean shouldResolve = item[2]
        boolean shouldTransitive = item[3]

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

            productionRuntimeMods("${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")

    // Misc
    runtimeOnly(project(path: ":forgeWrapper"))
}

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

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

loom {
    silentMojangMappingsLicense()

    interfaceInjection {
        enableDependencyInterfaceInjection.set(true)
    }

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

    runConfigs.named("client") {
        programArgs([
                "--width", Integer.parseInt(project.getOrDefault("ow.game.window.width", "1920") as String),
                "--height", Integer.parseInt(project.getOrDefault("ow.game.window.height", "1080") as String),
                "--username", project.getOrDefault("ow.game.window.username", "dev")
        ])
        runDir("run/client")
    }

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

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

        mixinAuditServer {
            inherit(server)
            vmArgs("-D${project.mod_id}.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()
        }
    }
     */

    forge {
        mixinConfigs = [
                "${project.mod_id}-carpet.mixins.json",
                "${project.mod_id}-event.mixins.json",
                "${project.mod_id}-language.mixins.json",
                "${project.mod_id}-malilib.mixins.json",
                "${project.mod_id}-minecraft-compat-api.mixins.json",
                "${project.mod_id}-util-qol.mixins.json"
        ]
    }
}

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", Integer.parseInt(project.getOrDefault("ow.game.window.width", "1920") as String),
                "--height", Integer.parseInt(project.getOrDefault("ow.game.window.height", "1080") as String),
                "--username", project.getOrDefault("ow.game.window.username", "dev")
        )
        jvmArgs("-Dmixin.debug.export=true")
        jvmArgs("-Dfabric.addMods=${configurations.productionRuntimeMods.files.join(File.pathSeparator)}${File.pathSeparator}${tasks.remapJar.archiveFile.get().asFile.absolutePath}${File.pathSeparator}${project(":fabricWrapper").tasks.jar.archiveFile.get()}")

        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}${File.pathSeparator}${project(":fabricWrapper").tasks.jar.archiveFile.get()}")
    }
}

["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.setEncoding("UTF-8")
    options.getCompilerArgs().add("-Xlint:-removal")
}

remapJar {
    remapperIsolation.set(true)
}

processResources {
    outputs.upToDateWhen { false }

    from("${rootDir}/LICENSE")

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

    filesMatching("META-INF/mods.toml") {
        expand([
                "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.getModVersion()
        ])
    }

    filesMatching("architectury.common.json") {
        filter { line ->
            line.trim().startsWith("//") ? "" : line
        }
    }
}

java {
    sourceCompatibility(JavaVersion.VERSION_1_8)
    targetCompatibility(JavaVersion.VERSION_1_8)
    withJavadocJar()
    withSourcesJar()
}

javadoc {
    options {
        source("17")
        encoding("UTF-8")
        charSet("UTF-8")
        addStringOption("Xdoclint:none", "-quiet")
    }

    include("**/api/**")
}

publishing() {
    publications {
        register("snapshot", MavenPublication) {
            artifactId("${project.mod_id}-${project.minecraft_version.replace(".", "_")}")
            from(components.java)
            version("${project.mod_version}-SNAPSHOT")

            project.addPomMetadataInformation(project, it)
        }

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

            project.addPomMetadataInformation(project, it)
        }
    }

    repositories {
        mavenLocal() {
            name("mavenLocal")
        }

        maven {
            name("projectLocalSnapshot")
            url("${rootDir}/publish/snapshot")
        }

        maven {
            name("projectLocalRelease")
            url("${rootDir}/publish/release")
        }

        maven {
            name("mavenCentralSnapshot")
            url("https://s01.oss.sonatype.org/content/repositories/snapshots/")

            project.credentialsMavenCentral(it)
        }

        maven {
            name("mavenCentralRelease")
            url("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/")

            project.credentialsMavenCentral(it)
        }
    }
}

signing {
    String signingKey = project.getOrDefault("secrets.gpg.signingKey", project.getENV().SIGNING_PGP_KEY)
    String signingPassword = project.getOrDefault("secrets.gpg.signingPassword", project.getENV().SIGNING_PGP_PASSWORD)

    required {
        signingKey
    }

    useInMemoryPgpKeys(signingKey, signingPassword ? signingPassword : "")
    sign(publishing.publications)
}

TaskCollection<Sign> signingTasks = tasks.withType(Sign)
tasks.withType(AbstractPublishToMaven).configureEach {
    it.dependsOn(signingTasks)
}

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("MagicLibReference")
        .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())
            }
        }
    }
}