plugins {
    id "org.jetbrains.kotlin.jvm" version "1.7.21" apply false
    id "com.google.devtools.ksp" version "1.7.21-1.0.8" apply false
    id 'jacoco'
    id 'io.codearte.nexus-staging' version '0.30.0'
}

if (hasProperty('buildScan')) {
    buildScan {
        termsOfServiceUrl = 'https://gradle.com/terms-of-service'
        termsOfServiceAgree = 'yes'
    }
}

nexusStaging {
    username = System.getenv().getOrDefault("REPO_USER", "")
    password = System.getenv().getOrDefault("REPO_PASSWORD", "")
    packageGroup = "ru.tinkoff"
}

allprojects {
    group = "ru.tinkoff.kora"
    version = System.getenv().getOrDefault("KORA_VERSION", "0.14.0-SNAPSHOT")
    repositories {
        mavenCentral()
    }
}

// config libraries
subprojects {
    if (!project.childProjects.isEmpty() || project.name == 'maven-parent') {
        return
    }
    apply plugin: 'java-library'
    java {
        toolchain {
            languageVersion.set(JavaLanguageVersion.of(17))
        }
    }

    tasks.withType(JavaCompile) {
        options.debug = true
        options.encoding = 'UTF-8'
        options.compilerArgs << '-parameters' << '-Xlint:all' << '-Xlint:-serial' << '-XprintRounds'
    }

}

// config test libraries
subprojects {
    if (project.parent.name != "internal") {
        return
    }
    dependencies {
        api libs.junit.platform.launcher
        api libs.junit.jupiter
    }
}

def isPublishedLibrary = { Project p ->
    if (!p.childProjects.isEmpty()) {
        return false
    }
    if (p.parent.name == "internal") {
        return false
    }
    if (p.name == "maven-parent") {
        return false
    }
    return true
}
subprojects {
    configurations {
        all {
            resolutionStrategy.force "com.fasterxml.jackson.core:jackson-annotations:" + libs.versions.jackson.get()
            resolutionStrategy.force "com.fasterxml.jackson.core:jackson-core:" + libs.versions.jackson.get()
            resolutionStrategy.force "com.fasterxml.jackson.core:jackson-databind:" + libs.versions.jackson.get()
            resolutionStrategy.force "io.netty:netty-buffer:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-codec:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-codec-dns:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-codec-http2:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-codec-http:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-codec-socks:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-codec-common:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-handler:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-handler-proxy:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-resolver:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-resolver-dns:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-resolver-dns-classes-macos:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-resolver-dns-classes-macos:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-transport:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-transport-clasess-epoll:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-transport-clasess-kqueue:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-transport-native-epoll:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-transport-native-kqueue:" + libs.versions.netty.get()
            resolutionStrategy.force "io.netty:netty-transport-unix-common:" + libs.versions.netty.get()
            resolutionStrategy.force "org.jetbrains.kotlin:kotlin-stdlib:" + libs.versions.kotlin.get().get()
            resolutionStrategy.force "org.jetbrains.kotlin:kotlin-stdlib-jdk7:" + libs.versions.kotlin.get().get()
            resolutionStrategy.force "org.jetbrains.kotlin:kotlin-stdlib-jdk8:" + libs.versions.kotlin.get().get()
        }
    }
}

// config published libraries
subprojects {
    if (!isPublishedLibrary(it)) {
        return
    }

    apply plugin: 'maven-publish'
    apply plugin: 'jacoco'
    apply plugin: 'signing'

    java {
        withSourcesJar()
        withJavadocJar()
    }

    publishing {
        publications {
            maven(MavenPublication) {
                from components.java
                pom {
                    afterEvaluate {
                        name = project.name
                        description = "Kora $project.name module"
                    }
                    licenses {
                        license {
                            name = 'The Apache Software License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    scm {
                        url = 'https://github.com/Tinkoff/kora'
                        connection = 'scm:git:git@github.com/Tinkoff/kora.git'
                        developerConnection = 'scm:git:git@github.com/Tinkoff/kora.git'
                    }
                    url = 'https://github.com/Tinkoff/kora'
                    developers {
                        developer {
                            id = 'a.otts'
                            name = 'Aleksei Otts'
                            email = 'eld0727@mail.ru'
                        }
                        developer {
                            id = 'a.duyun'
                            name = 'Anton Duyun'
                            email = 'anton.duyun@gmail.com'
                        }
                        developer {
                            id = 'a.kurako'
                            name = 'Anton Kurako'
                            email = 'goodforgod.dev@gmail.com'
                        }
                        developer {
                            id = 'a.yakovlev'
                            name = 'Artem Yakovlev'
                            email = 'jakart89@gmail.com'
                        }
                    }

                    withXml { pom ->
                        def xpf = javax.xml.xpath.XPathFactory.newInstance()
                        def xp = xpf.newXPath()
                        def xpath = xp.compile("//dependency[optional[contains(text(), 'true')]]")
                        def nl = (org.w3c.dom.NodeList) xpath.evaluate(pom.asElement(), javax.xml.xpath.XPathConstants.NODESET);
                        for (int i = nl.getLength() - 1; i >= 0; i--) {
                            nl.item(i).getParentNode().removeChild(nl.item(i))
                        }
                    }
                }
            }
        }
        repositories {
            maven { MavenArtifactRepository repo ->
                url = uri(System.getenv().getOrDefault("REPO_URL", "http://some-uri.com"))
                credentials {
                    username = System.getenv().getOrDefault("REPO_USER", "")
                    password = System.getenv().getOrDefault("REPO_PASSWORD", "")
                }
            }
        }
    }


    signing {
        required = false
        sign publishing.publications.maven
    }

    test {
        jvmArgs([
            '-XX:FlightRecorderOptions=stackdepth=1024',
            '--enable-preview',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED',
            '--add-opens', 'jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
        ])
        useJUnitPlatform()
        testLogging {
            showStandardStreams(false)
            events("passed", "skipped", "failed")
            exceptionFormat("full")
        }
        systemProperty "junit.jupiter.extensions.autodetection.enabled", "true"
        jacoco {
            enabled = false
        }
    }

    jacocoTestReport {
        reports {
            xml.required = true
            csv.required = false
            html.required = false
        }
    }

    dependencies {
        api libs.jsr305

        testImplementation project(":internal:test-logging")
        testImplementation libs.junit.jupiter
        testImplementation libs.mockito.core
        testImplementation libs.assertj
    }

    task allDeps(type: DependencyReportTask) {}
}

task jacocoRootReport(type: JacocoReport) {
    var jacocoSubprojects = subprojects.stream()
        .filter { isPublishedLibrary(it) }
        .toArray()
    dependsOn jacocoSubprojects.jacocoTestReport

    group = 'verification'
    executionData project.fileTree(dir: '.', include: '**/build/jacoco/test.exec')
    jacocoSubprojects.each { subproject ->
        subproject.tasks.withType(JacocoReport).each { report ->
            additionalClassDirs report.allClassDirs
            additionalSourceDirs report.allSourceDirs
        }
    }

    reports {
        xml.required = true
        csv.required = false
        html.required = false
    }
}

tasks.register("database-test") {
    group("verification")
    description("Run database tests")
    project.getAllprojects().stream()
        .filter((p) -> p.depth > 1 && p.name.startsWith("database") && p.tasks.findByPath("test") != null)
        .forEach((p) -> {
            dependsOn(":database:" + p.name + ":test")
        })
}

tasks.register("kafka-test") {
    group("verification")
    description("Run kafka tests")
    project.getAllprojects().stream()
        .filter((p) -> p.depth > 1 && p.name.startsWith("kafka") && p.tasks.findByPath("test") != null)
        .forEach((p) -> {
            dependsOn(":kafka:" + p.name + ":test")
        })
}

tasks.register("http-test") {t ->
    group("verification")
    description("Run http tests")
    project.childProjects["http"].subprojects { p ->
        def testTask = p.tasks.findByPath("test")
        if (p.name.startsWith("http") &&  testTask != null) {
            t.dependsOn(testTask)
        }
    }
}
def kspProjects = Set.of(
    'kora-app-symbol-processor',
    'json-symbol-processor',
    'cache-symbol-processor',
    'config-symbol-processor',
    'scheduling-ksp',
    'resilient-symbol-processor',
    'soap-client-symbol-processor',
    'aop-symbol-processor'
)

tasks.register("ksp-test") {
    group("verification")
    description("Run ksp tests")
    project.getAllprojects().stream()
        .filter((p) -> kspProjects.contains(p.name) && p.tasks.findByPath("test") != null)
        .forEach((p) -> {
            var name = p.name
            if (p.depth == 2) {
                name = p.parent.name + ":" + name
            }
            dependsOn(":" + name + ":test")
        })
}


tasks.register('openapi-test') {
    group('verification')
    description('Run openapi tests')
    dependsOn(':openapi:openapi-generator:test')
}


def isOtherTest = { Project p ->
    if (p.tasks.findByPath("test") == null) {
        return false
    }
    if (p.name == 'openapi-generator') {
        return false
    }
    if (p.name.startsWith("http") || p.name.startsWith("kafka") || p.name.startsWith("database")) {
        return false
    }
    if (p.parent.name == "internal") {
        return false
    }
    return !kspProjects.contains(p.name)
}

tasks.register("other-test") {
    group("verification")
    description("Run other tests")
    project.getAllprojects().stream()
        .filter(p -> isOtherTest(p))
        .forEach((p) -> {
            var name = p.name
            if (p.depth == 2) {
                name = p.parent.name + ":" + name
            }
            if (p.depth == 3) {
                name = p.parent.parent.name + ":" + p.parent.name + ":" + name
            }
            dependsOn(":" + name + ":test")
        })
}