buildscript {
    repositories {
        maven {
            name = 'Fabric'
            url = 'https://maven.fabricmc.net/'
        }
        gradlePluginPortal()
    }

    dependencies {
        classpath "gradle.plugin.com.matthewprenger:CurseGradle:1.4.0"
        classpath "gradle.plugin.com.modrinth.minotaur:Minotaur:1.2.1"
        classpath "net.fabricmc:fabric-loom:0.10-SNAPSHOT"
        classpath "org.ajoberstar.grgit:grgit-gradle:3.1.0"
    }
}

ext.curseforgeAvailable = project.hasProperty("curseforge_id")
ext.modrinthAvailable = project.hasProperty("modrinth_id")

apply plugin: 'idea'
apply plugin: 'java-library'
apply plugin: 'maven-publish'
if (ext.curseforgeAvailable) apply plugin: com.matthewprenger.cursegradle.CurseGradlePlugin
apply plugin: com.modrinth.minotaur.Minotaur
apply plugin: org.ajoberstar.grgit.gradle.GrgitPlugin

import com.modrinth.minotaur.request.VersionType

static Node getOrCreateNode(Node node, String name) {
    Node dependencies = null
    for(Node n : node) {
        if(name == n.name()) {
            dependencies = n
            break
        }
    }
    if(dependencies == null) {
        dependencies = node.appendNode(name)
    }
    return dependencies
}

ext.moduleDependencies = { Project project, List<String> depNames ->
    def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'dev') }
    project.dependencies {
        deps.each {
            api it
        }
    }
    project.publishing {
        publications {
            mavenJava(MavenPublication) {
                pom.withXml {
                    def depsNode = getOrCreateNode(asNode(), "dependencies")
                    deps.each {
                        def depNode = depsNode.appendNode("dependency")
                        depNode.appendNode("groupId", it.group)
                        depNode.appendNode("artifactId", it.name)
                        depNode.appendNode("version", it.version)
                        depNode.appendNode("scope", "compile")
                    }
                }
            }
        }
    }
}

// Fetch changelog
def changelogStr = ""
ext.currentVer = "0.0.0+nogit"
ext.currentType = VersionType.ALPHA
if (grgit != null) {
    ext.currentVer = "0.0.0+notag"
    grgit.open(dir: project.projectDir.toString())
    def tagList = grgit.tag.list()
    tagList.sort((left, right) -> right.commit.dateTime.compareTo(left.commit.dateTime))
    if (tagList.size() >= 1) {
        if (tagList.get(0).fullMessage != null) {
            changelogStr += tagList.get(0).fullMessage + "\n"
        }
        ext.currentType = VersionType.RELEASE
        ext.currentVer = tagList.get(0).getName()
        switch (ext.currentVer[0]) {
            case 'v':
                ext.currentVer = ext.currentVer.substring(1)
                break
            case 'b':
                ext.currentVer = ext.currentVer.substring(1)
                ext.currentType = VersionType.BETA
                break
            case 'a':
                ext.currentVer = ext.currentVer.substring(1)
                ext.currentType = VersionType.ALPHA
                break
        }
        def commits = new ArrayList<>(tagList.size() >= 2
            ? grgit.log{range(tagList.get(1).fullName, tagList.get(0).fullName)}
            : grgit.log(includes: [grgit.tag.list().get(0).fullName]))
        Collections.reverse(commits)
        changelogStr += "Commits in " + ext.currentType.toString().toLowerCase() + " " + ext.currentVer + ":\n"
        for (def commit : commits) {
            changelogStr += "- " + commit.shortMessage + "\n"
        }
    }
}
if (changelogStr == "") {
    changelogStr = "No changelog"
}
if (!project.hasProperty("release")) {
    ext.currentVer += "-" + Instant.now().getEpochSecond()
}
println(changelogStr)

if (!project.hasProperty("modrinth_required_dependencies"))
    project.ext.modrinth_required_dependencies = ""
else
    project.ext.modrinth_required_dependencies = project.modrinth_required_dependencies
if (!project.hasProperty("modrinth_optional_dependencies"))
    project.ext.modrinth_optional_dependencies = ""
else
    project.ext.modrinth_optional_dependencies = project.modrinth_optional_dependencies
if (!project.hasProperty("curseforge_required_dependencies"))
    project.ext.curseforge_required_dependencies = ""
else
    project.ext.curseforge_required_dependencies = project.curseforge_required_dependencies
if (!project.hasProperty("curseforge_optional_dependencies"))
    project.ext.curseforge_optional_dependencies = ""
else
    project.ext.curseforge_optional_dependencies = project.curseforge_optional_dependencies

allprojects {
    apply plugin: "java-library"
    apply plugin: "maven-publish"
    apply plugin: net.fabricmc.loom.bootstrap.LoomGradlePluginBootstrap

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

    if (project.hasProperty("archives_base_name"))
        archivesBaseName = project.archives_base_name
    group = project.maven_group
    version = "$rootProject.ext.currentVer"

    dependencies {
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings "net.fabricmc:yarn:${project.minecraft_version}+${project.yarn_mappings}:v2"
        modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
    }

    //loom {
    //    shareRemapCaches = true
    //}

    repositories {
        maven {
            name = 'TerraformersMC'
            url = 'https://maven.terraformersmc.com/'
        }
        maven {
            name = 'LibJF'
            url = 'https://gitlab.com/api/v4/projects/25805200/packages/maven'
        }
        mavenLocal()
        mavenCentral()
    }

    configurations {
        dev
    }

    jar {
        archiveClassifier = "dev"
    }

    afterEvaluate {
        remapJar {
            input = file("${project.buildDir}/libs/$archivesBaseName-${project.version}-dev.jar")
            archiveFileName = "${archivesBaseName}-${project.version}.jar"
        }

        artifacts {
            dev file: file("${project.buildDir}/libs/$archivesBaseName-${project.version}-dev.jar"), type: "jar", builtBy: jar
        }

        processResources {
            inputs.property "version", project.version

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

    java {
        withSourcesJar()
    }

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

subprojects {
    publishing {
        publications {
            mavenJava(MavenPublication) {
                afterEvaluate {
                    artifact(remapJar) {
                        builtBy remapJar
                    }

                    artifact(sourcesJar) {
                        builtBy remapSourcesJar
                    }
                }
            }
        }

        setupRepositories(repositories)
    }

    loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)

    javadoc.enabled = false

    afterEvaluate {
        genSources.enabled = false
        unpickJar.enabled = false
    }
}

task remapMavenJar(type: net.fabricmc.loom.task.RemapJarTask, dependsOn: jar) {
    input = jar.archiveFile
    archiveFileName = "${archivesBaseName}-${project.version}-maven.jar"
    addNestedDependencies = false
}
build.dependsOn remapMavenJar

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(remapMavenJar) {
                builtBy remapMavenJar
            }

            artifact(sourcesJar) {
                builtBy remapSourcesJar
            }

            pom.withXml {
                def depsNode = getOrCreateNode(asNode(), "dependencies")
                subprojects.each {
                    def depNode = depsNode.appendNode("dependency")
                    depNode.appendNode("groupId", it.group)
                    depNode.appendNode("artifactId", it.name)
                    depNode.appendNode("version", it.version)
                    depNode.appendNode("scope", "compile")
                }
            }
        }
    }

    setupRepositories(repositories)
}

loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)

void setupRepositories(RepositoryHandler repositories) {
    def ENV = System.getenv()
    if (project.hasProperty("maven")) {
        repositories.maven {
            url = project.getProperty("maven")
            name = "dynamic"

            credentials(HttpHeaderCredentials) {
                name = "Job-Token"
                value = ENV.CI_JOB_TOKEN
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
    repositories.mavenLocal()
}

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

dependencies {
    afterEvaluate {
        subprojects.each {
            api project(path: ":${it.name}", configuration: "dev")

            if (!project.hasProperty("dev_only_module") || !(it.name in project.getProperty("dev_only_module").split(", "))) {
                include it
            }

            testmodImplementation it.sourceSets.testmod.output
        }
    }
}

if (ext.modrinthAvailable) {
    task modrinth(type: com.modrinth.minotaur.TaskModrinthUpload, dependsOn: build) {
        token = System.getenv().MODRINTH_API_TOKEN
        projectId = project.modrinth_id
        versionNumber = version
        versionName = "[${project.minecraft_version}] ${version}"
        versionType = project.ext.currentType
        changelog = changelogStr
        uploadFile = file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar")
        addGameVersion("${project.minecraft_version}")
        addLoader('fabric')
        if (!project.ext.modrinth_required_dependencies.isEmpty()) {
            project.ext.modrinth_required_dependencies.split(", ").each {
                String dep -> addDependency(dep, com.modrinth.minotaur.request.Dependency.DependencyType.REQUIRED)
            }
        }
        if (!project.ext.modrinth_optional_dependencies.isEmpty()) {
            project.ext.modrinth_optional_dependencies.split(", ").each {
                String dep -> addDependency(dep, com.modrinth.minotaur.request.Dependency.DependencyType.OPTIONAL)
            }
        }
    }
}
else {
    task modrinth() {
    }
}

if (ext.curseforgeAvailable) {
    curseforge {
        if (System.getenv().CURSEFORGE_API_TOKEN) {
            apiKey = System.getenv().CURSEFORGE_API_TOKEN
        } else {
            println "No CURSEFORGE_API_TOKEN specified"
        }
        project {
            id = project.curseforge_id
            releaseType = 'release'
            addGameVersion "Fabric"
            addGameVersion "${project.minecraft_version}"
            changelog = changelogStr
            mainArtifact(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar"))
            mainArtifact.displayName = "[${project.minecraft_version}] ${version}"
            if (!project.ext.curseforge_required_dependencies.isEmpty() || !project.ext.curseforge_optional_dependencies.isEmpty()) {
                relations {
                    if (!project.ext.curseforge_required_dependencies.isEmpty()) {
                        project.ext.curseforge_required_dependencies.split(", ").each {
                            String dep -> requiredDependency dep
                        }
                    }
                    if (!project.ext.curseforge_optional_dependencies.isEmpty()) {
                        project.ext.curseforge_optional_dependencies.split(", ").each {
                            String dep -> optionalDependency dep
                        }
                    }
                }
            }
            releaseType = project.ext.currentType.toString().toLowerCase()
            afterEvaluate {
                uploadTask.dependsOn(build)
            }
        }
        options {
            forgeGradleIntegration = false
        }
    }
}
else {
    task curseforge() {
    }
}