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.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 = AfterEvaluateArgs(extensions.create("lom"), null, null)

        afterEvaluate { lomAfterEvaluate(args) } // Needs to be registered before loom to properly set things up

        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

        val completeJar by tasks.registering(ShadowJar::class) {
            dependsOn(inputTask)
            configurations.clear()
            configurations.add(project.configurations.shadow)
            archiveClassifier.set("shadow")
            destinationDirectory.set(devlibs)
        }
        args.completeJar = completeJar

        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)
            archiveFileName.set("$archiveBaseName-${project.versionS}-maven.jar")
            addNestedDependencies.set(false)
        }
        args.remapMavenJar = remapMavenJar
        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)
            archiveClassifier.set("testmod")
            addNestedDependencies.set(false)
        }
        tasks.assemble.dependsOn(remapTestmodJar)
    }

    private fun Project.lomAfterEvaluate(args: AfterEvaluateArgs) {
        val extension = args.extension
        val completeJar = args.completeJar!!
        val remapMavenJar = args.remapMavenJar!!

        tasks.withType<JavaCompile>().configureEach {
            options.encoding = "UTF-8"
            options.release.set(17)
        }

        dependencies {
            minecraft("com.mojang:minecraft:${extension.minecraftVersion.get()}")
            if (extension.yarnBuild != null) mappings("net.fabricmc:yarn:${extension.minecraftVersion.get()}+${extension.yarnBuild}:v2")
            else loom.officialMojangMappings()
            modImplementation("net.fabricmc:fabric-loader:${extension.loaderVersion.get()}")

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

        tasks.remapJar {
            dependsOn(completeJar)

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

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

        publishing {
            publications {
                create<MavenPublication>("mavenJava") {
                    artifact(remapMavenJar) {
                        builtBy(remapMavenJar)
                    }

                    artifact(tasks.sourcesJar) {
                        builtBy(tasks.remapSourcesJar)
                    }
                }
            }
        }
        tasks.publish.dependsOn(tasks.build)
        tasks.deployDebug.dependsOn(tasks.publish)
    }

    private data class AfterEvaluateArgs(val extension: LomExtension, var completeJar: ShadowJar?, var remapMavenJar: RemapJarTask?)
}