plugins {
    id 'fabric-loom' version '0.9.+'
    id 'java-library'
    id 'maven-publish'
    id 'com.github.johnrengelman.shadow' version '7.0.0'
    id 'org.cadixdev.licenser' version '0.6.1'
    id 'com.modrinth.minotaur' version '1.2.+'
}

import net.fabricmc.loom.task.RemapJarTask
import com.google.gson.GsonBuilder
import com.google.gson.JsonObject
import com.modrinth.minotaur.TaskModrinthUpload
import com.modrinth.minotaur.request.VersionType
import com.modrinth.minotaur.responses.ResponseError
import org.apache.http.client.config.CookieSpecs
import org.apache.http.client.config.RequestConfig
import org.apache.http.client.entity.EntityBuilder
import org.apache.http.client.methods.HttpPatch
import org.apache.http.entity.ContentType
import org.apache.http.impl.client.HttpClientBuilder
import org.apache.http.util.EntityUtils

group = project.maven_group
version = "${project.mod_version}+${getMCVersionString()}"
archivesBaseName = project.archives_base_name

// This field defines the Java version your mod target.
def targetJavaVersion = 16

boolean isMCVersionNonRelease() {
    return project.minecraft_version.matches('^\\d\\dw\\d\\d[a-z]$')
            || project.minecraft_version.matches('\\d+\\.\\d+-(pre|rc)(\\d+)')
}

String getMCVersionString() {
    if (isMCVersionNonRelease()) {
        return project.minecraft_version
    }
    def version = project.minecraft_version.split('\\.')
    return version[0] + '.' + version[1]
}

String parseReadme() {
    def excludeRegex = /(?m)<!-- modrinth_exclude\.start -->(.|\n)*?<!-- modrinth_exclude\.end -->/
    def linkRegex = /!\[([A-z_ ]+)]\((images\/[A-z.\/_]+)\)/

    def readme = (String) file('README.md').text
    readme = readme.replaceAll(excludeRegex, '')
    readme = readme.replaceAll(linkRegex, '![$1](https://raw.githubusercontent.com/LambdAurora/LambdaControls/1.17/$2)')
    return readme
}

minecraft {
    accessWidener file('src/main/resources/lambdacontrols.accesswidener')
}

repositories {
    mavenLocal()
    mavenCentral()
    maven { url 'https://aperlambda.github.io/maven' }
    maven {
        name 'Gegy'
        url 'https://maven.gegy.dev'
    }
    maven {
        name 'CottonMC'
        url 'https://server.bbkr.space:8081/artifactory/libs-snapshot'
    }
    maven {
        name 'Terraformers'
        url 'https://maven.terraformersmc.com/releases'
    }
    maven { url 'https://maven.shedaniel.me/' }
}

configurations {
    shadow
    api.extendsFrom shadow
}

dependencies {
    //to change the versions see the gradle.properties file
    minecraft "com.mojang:minecraft:${project.minecraft_version}"
    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

    // Fabric API. This is technically optional, but you probably want it anyway.
    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"

    modImplementation "dev.lambdaurora:spruceui:${project.spruceui_version}"
    include "dev.lambdaurora:spruceui:${project.spruceui_version}"

    modImplementation "com.terraformersmc:modmenu:${project.modmenu_version}"

    // Compatibility mods
    /*modImplementation("com.github.joaoh1:okzoomer:e13183c59b") {
        exclude group: 'me.shedaniel.cloth'
        exclude group: 'io.github.prospector'
    }*/

    shadow 'com.electronwill.night-config:core:3.6.3'
    shadow 'com.electronwill.night-config:toml:3.6.3'
}

java {
    sourceCompatibility = JavaVersion.toVersion(targetJavaVersion)
    targetCompatibility = JavaVersion.toVersion(targetJavaVersion)

    withSourcesJar()
}

tasks.withType(JavaCompile).configureEach {
    it.options.encoding = 'UTF-8'

    it.options.release.set(targetJavaVersion)
}

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

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

jar {
    from('LICENSE') {
        rename { "${it}_${project.archivesBaseName}" }
    }
}

license {
    header file('HEADER')
    include '**/*.java'
}

shadowJar {
    dependsOn jar
    configurations = [project.configurations.shadow]
    archiveClassifier.set('dev')

    exclude 'META-INF/maven/**'
    exclude 'com/google/**'
    exclude 'javax/**'
    exclude 'org/**'
    relocate 'com.electronwill.nightconfig', 'dev.lambdaurora.lambdacontrols.shadow.nightconfig'
}
remapJar.dependsOn(shadowJar)

task shadowRemapJar(type: RemapJarTask) {
    dependsOn shadowJar

    input.set(file("${project.buildDir}/libs/$archivesBaseName-$version-dev.jar"))
    archiveFileName = "${archivesBaseName}-${version}.jar"
    addNestedDependencies.set(true)
    remapAccessWidener.set(true)
}
build.dependsOn(shadowRemapJar)

task publishModrinth(type: TaskModrinthUpload) {
    dependsOn(build)
    onlyIf {
        System.getenv('MODRINTH_TOKEN')
    }

    token = System.getenv('MODRINTH_TOKEN')
    projectId = project.modrinth_id
    versionNumber = version
    versionName = "LambdaControls ${project.mod_version} (${getMCVersionString()})"
    uploadFile = shadowRemapJar
    addGameVersion((String) project.minecraft_version)
    addLoader('fabric')
    versionType = isMCVersionNonRelease() ? VersionType.BETA : VersionType.RELEASE

    // Changelog fetching
    def changelogText = file('CHANGELOG.md').text
    def regexVersion = ((String) project.mod_version).replaceAll('\\.', /\\./).replaceAll('\\+', '\\+')
    def changelogRegex = ~"###? ${regexVersion}\\n\\n(( *- .+\\n)+)"
    def matcher = changelogText =~ changelogRegex
    matcher.find()

    changelog = matcher.group(1)

    // Readme
    doFirst {
        final def client = HttpClientBuilder.create().setDefaultRequestConfig(RequestConfig.custom().setCookieSpec(CookieSpecs.IGNORE_COOKIES).build()).build()
        final def patch = new HttpPatch((String) (apiURL + '/v1/mod/' + projectId))
        patch.addHeader("Authorization", token)

        var json = new JsonObject()
        json.addProperty("body", parseReadme())
        patch.setEntity(EntityBuilder.create()
                .setText(json.toString())
                .setContentType(ContentType.APPLICATION_JSON)
                .build())

        final def response = client.execute(patch)
        final int status = response.getStatusLine().getStatusCode()

        final def gson = new GsonBuilder().create()
        if (status == 200) {
            project.getLogger().lifecycle("Successfully updated readme to ${projectId}.")
        } else {
            errorInfo = gson.fromJson(EntityUtils.toString(response.getEntity()), ResponseError.class)
            project.getLogger().error("Upload failed! Status: ${status} Error: ${errorInfo.getError()} Reason: ${errorInfo.getDescription()}")
            throw new GradleException("Upload failed! Status: ${status} Reason: ${errorInfo.getDescription()}")
        }
    }
}

// configure the maven publication
publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(shadowRemapJar) {
                builtBy shadowRemapJar
            }
            artifact(sourcesJar) {
                builtBy remapSourcesJar
            }

            pom {
                name = 'LambdaControls'
                description = 'Adds better controls, and controller support.'
            }

            pom.withXml {
                def dependenciesNode = asNode().appendNode('dependencies')

                configurations.shadow.allDependencies.each {
                    def dependencyNode = dependenciesNode.appendNode('dependency')

                    dependencyNode.appendNode('groupId', it.group)
                    dependencyNode.appendNode('artifactId', it.name)
                    dependencyNode.appendNode('version', it.version)
                    dependencyNode.appendNode('scope', 'compile')
                }
            }
        }
    }

    repositories {
        mavenLocal()
        maven {
            name "GithubPackages"
            url uri("https://maven.pkg.github.com/LambdAurora/LambdaControls")
            credentials {
                username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
                password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
            }
        }
        def lambdacontrolsMaven = System.getenv('LAMBDACONTROLS_MAVEN')
        if (lambdacontrolsMaven) {
            maven {
                name 'LambdaControlsMaven'
                url uri(lambdacontrolsMaven)
                credentials {
                    username = project.findProperty('gpr.user') ?: System.getenv('MAVEN_USERNAME')
                    password = project.findProperty('gpr.key') ?: System.getenv('MAVEN_PASSWORD')
                }
            }
        }
    }
}