Scripts/convention/src/main/kotlin/jf.autoversion.gradle.kts

import io.gitlab.jfronny.scripts.*
import org.eclipse.jgit.api.Git
import java.awt.Toolkit
import java.awt.datatransfer.StringSelection
import kotlin.jvm.optionals.getOrDefault

val isRelease = project.hasProperty("release")

versionS = "0.0.0+nogit"
versionType = VersionType.ALPHA
if (File(projectDir, ".git").exists()) {
    Git.open(projectDir).use { git ->
        versionS = "0.0.0+notag"
        val tags: List<Tag> = git.getTags()
        if (tags.isNotEmpty()) {
            if (tags[0].fullMessage != null) changelog += "${tags[0].fullMessage}\n"
            versionS = tags[0].name
            lastRelease = versionS
            val parsedVersion = SemanticVersion.parse(versionS)
            versionType = parsedVersion.type
            versionS = parsedVersion.unclassifiedToString()
            if (isRelease) {
                changelog += "Commits in ${versionType.displayName} $versionS:\n"
                changelog += git.log(if (tags.size >= 2) tags[1].peeledId else null, tags[0].peeledId)
                    .reversed()
                    .joinToString("\n") { "- ${it.shortMessage}" }
                nextRelease = parsedVersion
            } else {
                changelog += "Commits after ${versionType.displayName} $versionS:\n"
                val log = git.log(tags[0].peeledId, git.repository.resolve("HEAD")).reversed()
                changelog += log.joinToString("\n") { "- ${it.shortMessage}" }
                val type = log.stream()
                    .map { it.fullMessage }
                    .map { msg -> CommitType.from(msg) { logger.warn(it) } }
                    .max { o1, o2 -> o1.compareTo(o2) }
                    .getOrDefault(CommitType.FIX)
                nextRelease = parsedVersion.incrementBy(type)
            }
        } else {
            changelog += "Commits after inception:\n"
            changelog += git.log().all().call()
                .reversed()
                .joinToString("\n") { "- ${it.shortMessage}" }
        }
    }
} else changelog = "No changelog"

if (!isRelease) {
    versionS = "$nextRelease-SNAPSHOT"
}

println(changelog)

tasks.register("copyVersionNumber") {
    description = "Copy the current version number to the system clipboard"
    doLast {
        Toolkit.getDefaultToolkit().systemClipboard.setContents(StringSelection(versionS), null)
        println("Copied version number: $versionS")
    }
}

tasks.register("bumpVersion") {
    description = "Bump the version by parsing commits since the last tag and creating a new tag based on them"
    doLast {
        if (!File(projectDir, ".git").exists()) throw IllegalStateException("Cannot bump without repository")
        if (isRelease) throw IllegalStateException("Cannot bump while 'release' is set")
        if (!project.hasProperty("versionType")) throw IllegalStateException("bumpVersion requires you to set -PversionType=release|beta|alpha")
        val vt = VersionType.byName(prop("versionType")) ?: throw IllegalStateException("Unrecognized version type")
        val name = nextRelease!!.withType(vt).toString()
        Git.open(projectDir).use { git ->
            git.tag().setName(name).call()
            logger.warn("Created release $name (last was $lastRelease). Make sure to push it!")
        }
    }
}