import io.github.slimjar.resolver.data.Mirror
import org.ajoberstar.grgit.Grgit
import org.gradle.api.Task
import org.gradle.api.tasks.Copy
import org.gradle.api.tasks.TaskProvider
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.jvm.tasks.Jar
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.jetbrains.kotlin.gradle.dsl.JvmTarget

import java.net.URI

/*
 * Iris is a World Generator for Minecraft Bukkit Servers
 * Copyright (c) 2021 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

plugins {
    id 'java'
    id 'java-library'
    alias(libs.plugins.shadow)
    alias(libs.plugins.sentry)
    alias(libs.plugins.slimjar)
    alias(libs.plugins.grgit)
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.kotlin.lombok)
}

def apiVersion = '1.21'
def mainClass = 'art.arcane.iris.Iris'
def lib = 'art.arcane.iris.util'
String volmLibCoordinate = providers.gradleProperty('volmLibCoordinate')
    .orElse('com.github.VolmitSoftware:VolmLib:master-SNAPSHOT')
    .get()

/**
 * Dependencies.
 *
 * Provided or classpath dependencies are not shaded and are available on the runtime classpath
 *
 * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
 * need to be shaded into the jar (increasing binary size)
 *
 * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
 * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
 * these dependencies if they are available on mvn central.
 */
dependencies {
    // Provided or Classpath
    compileOnly(libs.spigot)
    compileOnly(libs.log4j.api)
    compileOnly(libs.log4j.core)

    // Third Party Integrations
    compileOnly(libs.nexo)
    compileOnly(libs.itemsadder)
    compileOnly(libs.placeholderApi)
    compileOnly(libs.score)
    compileOnly(libs.mmoitems)
    compileOnly(libs.ecoitems)
    compileOnly(libs.mythic)
    compileOnly(libs.mythicChrucible)
    compileOnly(libs.kgenerators) {
        transitive = false
    }
    compileOnly(libs.multiverseCore)

    // Shaded
    implementation('de.crazydev22.slimjar.helper:spigot:2.1.5')
    implementation(volmLibCoordinate) {
        changing = true
        transitive = false
    }

    // Dynamically Loaded
    slim(libs.paralithic)
    slim(libs.paperlib)
    slim(libs.adventure.api)
    slim(libs.adventure.minimessage)
    slim(libs.adventure.platform)
    slim(libs.bstats)
    slim(libs.sentry)

    slim(libs.commons.io)
    slim(libs.commons.lang)
    slim(libs.commons.lang3)
    slim(libs.commons.math3)
    slim(libs.oshi)
    slim(libs.lz4)
    slim(libs.fastutil)
    slim(libs.lru)
    slim(libs.zip)
    slim(libs.gson)
    slim(libs.asm)
    slim(libs.caffeine)
    slim(libs.byteBuddy.core)
    slim(libs.byteBuddy.agent)
    slim(libs.dom4j)
    slim(libs.jaxen)

    // Script Engine
    slim(libs.kotlin.stdlib)
    slim(libs.kotlin.coroutines)

    testImplementation('junit:junit:4.13.2')
    testImplementation('org.mockito:mockito-core:5.16.1')
    testImplementation(libs.spigot)
    testRuntimeOnly(libs.spigot)
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

kotlin {
    jvmToolchain(21)
    compilerOptions {
        jvmTarget.set(JvmTarget.JVM_21)
    }
}

sentry {
    url = 'http://sentry.volmit.com:8080'
    autoInstallation.enabled = false
    includeSourceContext = true

    org = 'sentry'
    projectName = 'iris'
    authToken = findProperty('sentry.auth.token') as String ?: System.getenv('SENTRY_AUTH_TOKEN')
}

slimJar {
    mirrors = [
        new Mirror(
            URI.create('https://maven-central.storage-download.googleapis.com/maven2').toURL(),
            URI.create('https://repo.maven.apache.org/maven2/').toURL()
        )
    ]

    relocate('com.dfsek.paralithic', "${lib}.paralithic")
    relocate('io.papermc.lib', "${lib}.paper")
    relocate('net.kyori', "${lib}.kyori")
    relocate('org.bstats', "${lib}.metrics")
    relocate('io.sentry', "${lib}.sentry")
    relocate('org.apache.maven', "${lib}.maven")
    relocate('org.codehaus.plexus', "${lib}.plexus")
    relocate('org.eclipse.sisu', "${lib}.sisu")
    relocate('org.eclipse.aether', "${lib}.aether")
    relocate('com.google.inject', "${lib}.guice")
    relocate('org.dom4j', "${lib}.dom4j")
    relocate('org.jaxen', "${lib}.jaxen")
    relocate('com.github.benmanes.caffeine', "${lib}.caffeine")
}

def embeddedAgentJar = project(':core:agent').tasks.named('jar', Jar)
def templateSource = file('src/main/templates')
def templateDest = layout.buildDirectory.dir('generated/sources/templates')
def generateTemplates = tasks.register('generateTemplates', Copy) {
    inputs.properties([
        environment: providers.provider {
            if (project.hasProperty('release')) {
                return 'production'
            }
            if (project.hasProperty('argghh')) {
                return 'Argghh!'
            }
            return 'development'
        },
        commit: providers.provider {
            String commitId = null
            Exception failure = null
            try {
                commitId = project.extensions.getByType(Grgit).head().id
            } catch (Exception ex) {
                failure = ex
            }

            if (commitId != null && commitId.length() == 40) {
                return commitId
            }

            logger.error('Git commit hash not found', failure)
            return 'unknown'
        },
    ])

    from(templateSource)
    into(templateDest)
    rename { String fileName -> "art/arcane/iris/${fileName}" }
    expand(inputs.properties)
}

tasks.named('compileJava', JavaCompile).configure {
    /**
     * We need parameter meta for the decree command system
     */
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.debugOptions.debugLevel = 'none'
}

tasks.named('processResources').configure {
    /**
     * Expand properties into plugin yml
     */
    def pluginProperties = [
        name      : rootProject.name,
        version   : rootProject.version,
        apiVersion: apiVersion,
        main      : mainClass,
    ]
    inputs.properties(pluginProperties)
    filesMatching('**/plugin.yml') {
        expand(pluginProperties)
    }
}

def runningTestTasks = gradle.startParameter.taskNames.any { String taskName -> taskName.toLowerCase().contains('test') }
if (runningTestTasks) {
    TaskProvider<Task> processResourcesTask = tasks.named('processResources')
    tasks.named('classes').configure { Task classesTask ->
        Set<Object> dependencies = new LinkedHashSet<Object>(classesTask.getDependsOn())
        dependencies.removeIf { Object dependency ->
            if (dependency instanceof TaskProvider) {
                return ((TaskProvider<?>) dependency).name == processResourcesTask.name
            }
            if (dependency instanceof Task) {
                return ((Task) dependency).name == processResourcesTask.name
            }
            String dependencyName = String.valueOf(dependency)
            return dependencyName == 'processResources' || dependencyName.endsWith(':processResources')
        }
        classesTask.setDependsOn(dependencies)
    }
    processResourcesTask.configure { Task task ->
        task.enabled = false
    }
}

tasks.named('shadowJar', com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar).configure {
    dependsOn(embeddedAgentJar)
    mergeServiceFiles()
    //minimize()
    relocate('io.github.slimjar', "${lib}.slimjar")
    exclude('modules/loader-agent.isolated-jar')
    from(embeddedAgentJar.map { it.archiveFile }) {
        rename { String ignored -> 'agent.jar' }
    }
}

tasks.named('sentryCollectSourcesJava').configure {
    dependsOn(generateTemplates)
}

tasks.named('generateSentryBundleIdJava').configure {
    dependsOn(generateTemplates)
}

rootProject.tasks.matching {
    it.name == 'prepareKotlinBuildScriptModel'
}.configureEach {
    dependsOn(generateTemplates)
}

sourceSets {
    main {
        java {
            srcDir(generateTemplates.map { it.outputs })
        }
    }
}