buildscript {
    repositories {
        mavenCentral()
    }
}

plugins {
    id 'java'
    id 'org.sonarqube' version '3.4.0.2513'
    id 'org.springframework.boot' version '2.6.15'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
    id 'com.palantir.docker' version '0.28.0'
    id 'maven-publish'
    id 'project-report'
    id 'build-dashboard'
    id 'com.github.jk1.dependency-license-report' version '1.17'
    id 'org.openjfx.javafxplugin' version '0.0.13'
}

sonarqube {
    properties {
        property "sonar.projectKey", "Java-Service-Tree-Framework-Middle-Proxy"
        property "sonar.host.url", "http://www.313.co.kr/sonar"
        property "sonar.login", "admin"
        property "sonar.password", "qwe123"
    }
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

javadoc {
    destinationDir = file("${buildDir}/docs/javadoc")
}

import com.github.jk1.license.render.*
import com.github.jk1.license.importer.*

licenseReport {
    outputDir = "$projectDir/build/licenses"
    projects = [project] + project.subprojects
    configurations = ['runtimeClasspath']
    excludeGroups = ['do.not.want']
    excludes = ['moduleGroup:moduleName']
    excludeOwnGroup = true
    excludeBoms = false
    renderers = [new InventoryHtmlReportRenderer("index.html", "Backend")]
    allowedLicensesFile = new File("$projectDir/allowed-licenses.json")
}

import org.apache.tools.ant.taskdefs.condition.Os

ext {
    image = "313devgrp/java-service-tree-framework-middle-proxy"

    repositoryUrl = "http://www.313.co.kr/nexus/repository/ple-releases/"
    metadataUrl = "${repositoryUrl}313devgrp/Java-Service-Tree-Framework-Middle-Proxy/maven-metadata.xml"

    //version 정보
    majorVersion = 26
    minorVersion = 4
    //patchVersion = auto generation

    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        println "*** Windows "
    } else if (Os.isFamily(Os.FAMILY_MAC)) {
        println "*** Mac "
    } else {
        exec {
            executable "wget"
            args "-O", "${projectDir}/metadata.xml", "${metadataUrl}"
        }
    }
    def metadataFile = new XmlSlurper().parse(new File("${projectDir}/metadata.xml"))
    String latest = metadataFile."versioning"."latest"
    String versionPrefix = latest.split("-")[0]
    def (latestMajorVersion, latestMinorVersion, latestPatchVersion) = versionPrefix.tokenize(".")
    if (majorVersion > latestMajorVersion.toInteger()) {
        minorVersion = 0
        patchVersion = 0
    } else if (minorVersion > latestMinorVersion.toInteger()) {
        patchVersion = 0
    } else {
        patchVersion = latestPatchVersion.toInteger() + 1
    }
}

task printVersion() {
    doLast {
        println bootJar.version
    }
}

group = "313devgrp"
version = "${majorVersion}.${minorVersion}.${patchVersion}"

bootJar {
    baseName = project.name
    version = project.version
}

task generatePublishInfo {
    def targetFile = new File("${projectDir}/spinnaker.properties")
    targetFile.parentFile.mkdirs()
    targetFile.withWriter("UTF-8") { w ->
        w.writeLine "groupId = " + project.group
        w.writeLine "artifactId = " + project.name
        w.writeLine "version = " + project.version
    }
}

publish {
    dependsOn generatePublishInfo
}

def getMavenSettingsCredentials = {
    String userHome = System.getProperty("user.home")
    File mavenSettings = new File(userHome, ".m2/settings.xml")

    if (Os.isFamily(Os.FAMILY_WINDOWS) || Os.isFamily(Os.FAMILY_MAC)) {
        if (!mavenSettings.exists()) {
            mavenSettings = new File("${projectDir}/settings.xml")
        }
    } else {
        if (!mavenSettings.exists()) {
            mavenSettings = new File("${projectDir}/settings.xml")
        }
    }
    def xmlSlurper = new XmlSlurper()
    def output = xmlSlurper.parse(mavenSettings)
    return output."servers"."server"
}

def getCredentials = {
    def entries = getMavenSettingsCredentials()

    for (entry in entries) {
        if (project.version.endsWith("-SNAPSHOT") && entry."id".text() == "snapshots") {
            return [username: entry.username.text(), password: entry.password.text()]
        } else {
            return [username: entry.username.text(), password: entry.password.text()]
        }
    }
}

publishing {
    def mvnCredential = getCredentials()
    repositories {
        maven {
            credentials {
                username mvnCredential["username"]
                password mvnCredential["password"]
            }
            url "${repositoryUrl}"
            allowInsecureProtocol = true
        }
    }

    publications {
        maven(MavenPublication) {
            groupId = project.group
            artifactId = project.name
            version = project.version
            artifact bootJar
        }
    }
}

repositories {
    mavenCentral()
    maven {
        url 'http://www.313.co.kr/nexus/repository/ple-releases/'
        allowInsecureProtocol true
    }
}

dependencyManagement {
    imports {
        mavenBom 'org.springframework.cloud:spring-cloud-dependencies:2021.0.9'
        mavenBom 'org.keycloak.bom:keycloak-adapter-bom:18.0.2'
    }
}

test {
    useJUnitPlatform()
}

dependencies {

    // Lombok
    implementation 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testCompileOnly 'org.projectlombok:lombok'

    // Test
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude module: 'junit'
    }

    // Spring Boot
    implementation 'org.springframework.boot:spring-boot-starter-aop'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'

    // Spring Cloud
    implementation 'org.springframework.cloud:spring-cloud-starter-gateway'
    implementation 'org.springframework.cloud:spring-cloud-starter-config'
    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
    implementation 'org.springframework.cloud:spring-cloud-starter-sleuth'
    implementation 'org.springframework.cloud:spring-cloud-sleuth-zipkin'

    // Spring Security OAuth2
    implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
    implementation 'org.springframework.boot:spring-boot-starter-oauth2-resource-server'
    implementation 'org.springframework.security:spring-security-oauth2-jose'

    // Redis Session
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.springframework.session:spring-session-data-redis'

    // Keycloak
    implementation('org.keycloak:keycloak-spring-boot-starter') {
        exclude group: 'org.apache.tomcat.embed', module: 'tomcat-embed-core'
        exclude group: 'org.apache.tomcat.embed', module: 'tomcat-embed-el'
        exclude group: 'org.apache.tomcat.embed', module: 'tomcat-embed-websocket'
    }
    implementation 'org.keycloak:keycloak-spring-security-adapter:18.0.2'
    implementation 'org.keycloak:keycloak-admin-client:18.0.2'

    // Kafka
    implementation 'org.springframework.kafka:spring-kafka'

    // Swagger
    implementation 'io.springfox:springfox-boot-starter:3.0.0'
    implementation 'io.springfox:springfox-swagger-ui:3.0.0'

    // Slack
    implementation 'com.slack.api:slack-api-client:1.25.1'

    // Netty (macOS)
    implementation 'io.netty:netty-resolver-dns-native-macos:4.1.130.Final:osx-aarch_64'
}

docker {
    name "313.co.kr:5550/${image}:${project.version}"
    noCache true
    tags "${project.version}"
    files tasks.bootJar.outputs.files, 'docker-entrypoint.sh'
    buildArgs(['JAR_FILE': tasks.bootJar.outputs.files.singleFile.name, 'ENTRY_FILE': 'docker-entrypoint.sh'])
}

bootRun {
    jvmArgs = [
            '--add-opens', 'java.base/java.util.jar=ALL-UNNAMED'
    ]
}

tasks.withType(Javadoc) {
    options.addStringOption('Xdoclint:none', '-quiet')
    failOnError = false
}