build.gradle

import org.springframework.boot.gradle.tasks.bundling.BootJar

plugins {
    alias(libs.plugins.spring.boot) apply false
    alias(libs.plugins.spotless) apply false
    alias(libs.plugins.hibernate.orm) apply false
    alias(libs.plugins.dependency.graph.generator)
}

group = "com.icc.qasker"

version = "3.7.2"

subprojects {
    tasks.configureEach { task ->
        if (task.name == "compileJava") {
            task.dependsOn(rootProject.tasks.named("installGitHooks"))
        }
    }

    dependencyLocking {
        lockAllConfigurations()
    }

    tasks.register("resolveAndLockAll") {
        notCompatibleWithConfigurationCache("Filters configurations at execution time")
        doFirst {
            assert gradle.startParameter.writeDependencyLocks: "--write-locks 플래그와 함께 실행하세요"
        }
        doLast {
            configurations.findAll { it.canBeResolved }*.resolve()
        }
    }

    apply plugin: 'java'
    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(25)
        }
    }

    dependencies {

        implementation platform(libs.spring.boot.bom)
        annotationProcessor platform(libs.spring.boot.bom)
        implementation platform(libs.spring.ai.bom)
        implementation platform(libs.google.cloud.bom)

        compileOnly "org.projectlombok:lombok"
        annotationProcessor "org.projectlombok:lombok"
        implementation "org.springframework.boot:spring-boot-starter-validation"
    }

    configurations {
        compileOnly {
            extendsFrom annotationProcessor
        }
    }

    repositories {
        mavenCentral()
    }

    apply plugin: 'com.diffplug.spotless'

    spotless {
        java {
            googleJavaFormat(libs.versions.google.java.format.get())
            removeUnusedImports()
            endWithNewline()
            trimTrailingWhitespace()
        }
    }

    configurations.configureEach {
        resolutionStrategy.eachDependency {
            if (it.requested.group == 'org.hibernate.orm') {
                it.useVersion(libs.versions.hibernate.orm.get())
            }
        }
    }

    apply plugin: 'org.hibernate.orm'
    if (project.path == ':quiz-set-impl' && !project.hasProperty('disableHibernateEnhancement')) {
        hibernate {
            enhancement {}
        }
    }

    tasks.withType(Test).configureEach {
        useJUnitPlatform()
        testLogging {
            showStandardStreams = true
        }
        if (project.hasProperty('testMaxHeap')) {
            maxHeapSize = project.property('testMaxHeap')
        }
        if (project.hasProperty('testMinHeap')) {
            minHeapSize = project.property('testMinHeap')
        }
        if (project.hasProperty('testGcLog')) {
            jvmArgs += ['-Xlog:gc*:stdout:time,level,tags']
        }
    }

    tasks.withType(JavaCompile).configureEach {
        options.compilerArgs += '-parameters'
    }

    tasks.withType(Jar).configureEach {
        duplicatesStrategy = DuplicatesStrategy.FAIL
    }

    tasks.withType(BootJar).configureEach {
        duplicatesStrategy = DuplicatesStrategy.FAIL
    }

}

tasks.register("installGitHooks") {
    description = "Git hooks 경로를 .githooks/로 설정"
    group = "setup"
    doLast {
        exec {
            commandLine("git", "config", "core.hooksPath", ".githooks")
        }
        logger.lifecycle("✅ Git hooks 경로가 .githooks/로 설정되었습니다.")
    }
}

tasks.register("dependencyGraphStyled") {
    dependsOn("generateProjectDependencyGraph")
    group = "reporting"
    description = "스타일이 적용된 모듈 의존성 그래프를 생성합니다"

    def inputDir = file("build/reports/project-dependency-graph")
    def outputDir = file("build/reports/dependency-graph-styled")

    doLast {
        def dotFile = new File(inputDir, "project-dependency-graph.dot")
        if (!dotFile.exists()) {
            throw new GradleException("DOT 파일이 없습니다: ${dotFile}")
        }

        outputDir.mkdirs()

        def dotContent = dotFile.text
        def edges = []
        def nodes = [] as Set

        dotContent.eachLine { line ->
            line = line.trim()
            def edgeMatcher = line =~ /^"([^"]+)"\s*->\s*"([^"]+)"(.*)$/
            if (edgeMatcher.matches()) {
                def from = edgeMatcher[0][1]
                def to = edgeMatcher[0][2]
                def attrs = edgeMatcher[0][3]?.trim() ?: ""
                nodes << from
                nodes << to
                edges << [from: from, to: to, attrs: attrs]
            }
            def nodeMatcher = line =~ /^"([^"]+)"\s*\[.*$/
            if (nodeMatcher.matches() && !line.contains("->")) {
                nodes << nodeMatcher[0][1]
            }
        }

        def implNodes = nodes.findAll { it.endsWith("-impl") }
        def apiNodes = nodes.findAll { it.endsWith("-api") }
        def appNode = nodes.find { it == ":app" }
        def globalNode = nodes.find { it == ":global" }

        def appToImpl = edges.findAll { it.from == ":app" && it.to.endsWith("-impl") }
        def implToOwnApi = edges.findAll { e ->
            e.from.endsWith("-impl") && e.to.endsWith("-api") &&
                e.from.replace("-impl", "") == e.to.replace("-api", "")
        }
        def crossDeps = edges.findAll { e ->
            e.from.endsWith("-impl") && e.to.endsWith("-api") &&
                e.from.replace("-impl", "") != e.to.replace("-api", "")
        }
        def apiToApi = edges.findAll { e ->
            e.from.endsWith("-api") && e.to.endsWith("-api")
        }
        def toGlobal = edges.findAll { e ->
            e.to == ":global" && !e.from.endsWith("-api")
        }
        def apiToGlobal = edges.findAll { e ->
            e.to == ":global" && e.from.endsWith("-api")
        }

        def styled = new StringBuilder()
        styled.append("""digraph {
  graph [
    dpi="100"
    label="${rootProject.name} Module Dependency Graph"
    labelloc="t"
    fontsize="28"
    fontname="Helvetica Neue"
    bgcolor="#FAFAFA"
    pad="0.8"
    nodesep="1.0"
    ranksep="1.5"
    rankdir="TB"
    splines="polyline"
  ]
  node [
    style="filled,rounded"
    shape="box"
    fontname="Helvetica Neue"
    fontsize="14"
    penwidth="1.5"
    margin="0.25,0.12"
  ]
  edge [
    dir="forward"
    color="#90A4AE"
    penwidth="1.2"
    arrowsize="0.7"
  ]

""")

        if (appNode) {
            styled.append("""  "${appNode}" [label="app" fillcolor="#1A237E" fontcolor="white" pencolor="#0D47A1" fontsize="16"]\n""")
        }
        implNodes.sort().each { n ->
            def label = n.replaceFirst(":", "")
            styled.append("""  "${n}" [label="${label}" fillcolor="#42A5F5" fontcolor="white" pencolor="#1E88E5"]\n""")
        }
        apiNodes.sort().each { n ->
            def label = n.replaceFirst(":", "")
            styled.append("""  "${n}" [label="${label}" fillcolor="#A5D6A7" fontcolor="#1B5E20" pencolor="#66BB6A"]\n""")
        }
        if (globalNode) {
            styled.append("""  "${globalNode}" [label="global" fillcolor="#FFB74D" fontcolor="#E65100" pencolor="#FFA726" fontsize="16"]\n""")
        }

        styled.append("\n  { rank=\"same\"; ${implNodes.sort().collect { "\"${it}\"" }.join("; ")} }\n")
        styled.append("  { rank=\"same\"; ${apiNodes.sort().collect { "\"${it}\"" }.join("; ")} }\n\n")

        appToImpl.each { e -> styled.append("  \"${e.from}\" -> \"${e.to}\"\n") }
        styled.append("\n")
        implToOwnApi.each { e -> styled.append("  \"${e.from}\" -> \"${e.to}\"\n") }
        styled.append("\n")
        crossDeps.each { e -> styled.append("  \"${e.from}\" -> \"${e.to}\" [color=\"#EF5350\" style=\"dashed\" constraint=\"false\"]\n") }
        styled.append("\n")
        apiToApi.each { e -> styled.append("  \"${e.from}\" -> \"${e.to}\" [color=\"#7E57C2\" penwidth=\"1.8\" constraint=\"false\"]\n") }
        styled.append("\n")
        apiToGlobal.each { e -> styled.append("  \"${e.from}\" -> \"${e.to}\" [style=\"dotted\" color=\"#BDBDBD\"]\n") }
        styled.append("\n")

        styled.append("""
  subgraph cluster_legend {
    label="Legend"
    fontname="Helvetica Neue"
    fontsize="13"
    style="rounded"
    color="#E0E0E0"
    bgcolor="white"
    margin="16"
    labeljust="l"
    edge [style="invis"]
    l1 [label="app (진입점)"     fillcolor="#1A237E" fontcolor="white" pencolor="#0D47A1"]
    l2 [label="impl (구현)"      fillcolor="#42A5F5" fontcolor="white" pencolor="#1E88E5"]
    l3 [label="api (인터페이스)" fillcolor="#A5D6A7" fontcolor="#1B5E20" pencolor="#66BB6A"]
    l4 [label="global (공통)"    fillcolor="#FFB74D" fontcolor="#E65100" pencolor="#FFA726"]
    l1 -> l2 -> l3 -> l4
  }
}
""")

        def styledDot = new File(outputDir, "dependency-graph-styled.dot")
        styledDot.text = styled.toString()
        logger.lifecycle("✅ DOT 파일 생성: ${styledDot}")

        try {
            exec {
                commandLine("dot", "-Tsvg", "-o", "${outputDir}/dependency-graph-styled.svg", styledDot.absolutePath)
            }
            def svgFile = new File(outputDir, "dependency-graph-styled.svg")
            def svgContent = svgFile.text
            svgFile.text = svgContent.replaceFirst(/<svg width="[^"]*" height="[^"]*"/, '<svg width="100%" height="100vh"')
            logger.lifecycle("✅ SVG 생성: ${svgFile}")
        } catch (Exception e) {
            logger.warn("⚠️ Graphviz(dot)가 설치되어 있지 않습니다. DOT 파일만 생성되었습니다.")
            logger.warn("   설치: brew install graphviz")
        }
    }
}