Scripts/lom/src/main/kotlin/io/gitlab/jfronny/lom/LomPlugin.kt

package io.gitlab.jfronny.lom

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import io.gitlab.jfronny.convention.ext.deployDebug
import io.gitlab.jfronny.convention.ext.versionS
import io.gitlab.jfronny.lom.ext.*
import io.gitlab.jfronny.lom.ext.registering
import net.fabricmc.loom.task.PrepareJarRemapTask
import net.fabricmc.loom.task.RemapJarTask
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.tasks.bundling.AbstractArchiveTask
import org.gradle.api.tasks.bundling.Jar
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*
import java.io.File

class LomPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        target.applyLom()
    }

    private fun Project.applyLom() {
        val devlibs = File(project.buildDir, "devlibs")
        val args = extensions.create<LomExtension>("lom")

        afterEvaluate {
            // Needs to be registered before loom to properly set things up
            dependencies {
                minecraft("com.mojang:minecraft:${args.minecraftVersion.get()}")
                if (args.yarnBuild != null) mappings("net.fabricmc:yarn:${args.minecraftVersion.get()}+${args.yarnBuild}:v2")
                else loom.officialMojangMappings()
                modImplementation("net.fabricmc:fabric-loader:${args.loaderVersion.get()}")

                testmodImplementation(sourceSets.main.output)
                testmodImplementation(sourceSets.client.output)
            }
        }

        apply(plugin = "idea")
        apply(plugin = "java-library")
        apply(plugin = "fabric-loom")
        apply(plugin = "maven-publish")
        apply(plugin = "com.github.johnrengelman.shadow")

        loom {
            runtimeOnlyLog4j.set(true)
            splitEnvironmentSourceSets()

            mods {
                register(name) {
                    sourceSet(sourceSets.main)
                    sourceSet(sourceSets.client)
                }
                register("$name-testmod") {
                    sourceSet(sourceSets.testmod)
                }
            }
        }

        sourceSets {
            create("testmod") {
                compileClasspath += sourceSets.main.compileClasspath
                runtimeClasspath += sourceSets.main.runtimeClasspath

                compileClasspath += sourceSets.client.compileClasspath
                runtimeClasspath += sourceSets.client.runtimeClasspath
            }
        }

        repositories {
            maven {
                name = "TerraformersMC"
                url = uri("https://maven.terraformersmc.com/")
            }
            maven {
                name = "LibJF"
                url = uri("https://gitlab.com/api/v4/projects/25805200/packages/maven")
            }
            maven {
                name = "JF Gson"
                url = uri("https://gitlab.com/api/v4/projects/35030495/packages/maven")
            }
            maven {
                name = "JF Commons"
                url = uri("https://gitlab.com/api/v4/projects/35745143/packages/maven")
            }
            maven {
                name = "JF FLoader"
                url = uri("https://gitlab.com/api/v4/projects/36014652/packages/maven")
            }
            mavenCentral()
            mavenLocal()
        }

        configurations.create("dev")
        tasks.jar.archiveClassifier.set("dev")

        val inputTask: Jar = tasks.findByName("injectCompiledConfig") as Jar? ?: tasks.jar

        tasks.shadow {
            dependsOn(inputTask)
            configurations.clear()
            from(project.configurations.shadow, tasks.jar.archiveFile.get())
            archiveClassifier.set("shadow")
            destinationDirectory.set(devlibs)
        }
        val completeJar = tasks.shadow

        artifacts.add("dev", tasks.jar.archiveFile.get().asFile) {
            type = "jar"
            builtBy(tasks.jar)
        }

        java {
            withSourcesJar()
        }

        tasks.withType<AbstractArchiveTask>() {
            isPreserveFileTimestamps = false
            isReproducibleFileOrder = false
        }

        val remapMavenJar by tasks.registering(RemapJarTask::class) {
            dependsOn(completeJar)
            inputFile.set(completeJar.archiveFile.get())
            archiveFileName.set("${archiveBaseName.get()}-${project.versionS}-maven.jar")
            addNestedDependencies.set(false)
        }
        tasks.assemble.dependsOn(remapMavenJar)

        val testmodJar by tasks.registering(Jar::class) { //TODO include deps
            from(sourceSets.testmod.output)
            destinationDirectory.set(devlibs)
            archiveClassifier.set("testmod")
        }

        val remapTestmodJar by tasks.registering(RemapJarTask::class) {
            dependsOn(testmodJar)
            inputFile.set(testmodJar.archiveFile.get())
            archiveClassifier.set("testmod")
            addNestedDependencies.set(false)
        }
        tasks.assemble.dependsOn(remapTestmodJar)

        tasks.remapJar {
            dependsOn(completeJar)
            inputFile.set(completeJar.archiveFile.get())
            archiveFileName.set("${archiveBaseName.get()}-${project.versionS}.jar")
        }

        tasks.processResources {
            filesMatching("fabric.mod.json") {
                expand(mapOf("version" to project.versionS))
            }
        }

        publishing {
            publications {
                create<MavenPublication>("mavenJava") {
                    from(components["java"])
                    setArtifacts(listOf(remapMavenJar, tasks.sourcesJar))
                }
            }
        }
        tasks.publish.dependsOn(tasks.build)
        tasks.deployDebug.dependsOn(tasks.publish)

        afterEvaluate {
            tasks.withType<JavaCompile>().configureEach {
                options.encoding = "UTF-8"
                options.release.set(17)
            }
            
            // Fix prepareRemapJar
            // Finds remapJar tasks and the corresponding prepareRemapJar tasks and ensures the dependencies of remapJar are run before prepareRemapJar
            // This ensures the input files exist when the task is run
            tasks.configureEach {
                if (this is RemapJarTask) {
                    this.dependsOn.filterIsInstance<PrepareJarRemapTask>().forEach { prepareTask ->
                        prepareTask.dependsOn(*this.dependsOn.filter { it != prepareTask }.toTypedArray())
                    }
                }
            }
        }
    }
}